Android渗透工具之Drozer源码分析

2023年9月1日 325次阅读 来源: Android源码分析

       最近时间比较充足，想找点事情来做做。再说Drozer这工具整天在手头用得着，只知其玄乎，又听大B哥说其架构是如何的NB。所以，就趁着这份热尽，体会了Drozer的神乎。确实挺神乎的，本人小菜一枚，求各位大神轻虐，在此放过了；如有想体会Drozer的神乎的朋友，在这抛砖引玉，不求感激，只求不坑了各位，哈哈、、、、

1.    Drozer简介

       Drozer是一个由MWR安全团队维护开源的软件，该软件可以说是针对Android平台的安全测试框架。安全人员可以通过Drozer自身提供的一些module完成一些基础的安全测试功能，同时也可以根据需求实现自己的module，甚至可以在利用Drozer提供的框架实现一些自动化审计功能。于目标设备上安装Agent，可以通过Agent接收PC端传来的指令或者代码并与Dalvik VM，其他app以及操作系统进行交互以达到某些安全审计功能。关于Drozer的源码可以从Github（https://github.com/mwrlabs）上获取:

drozer: 包含了控制台与服务端代码；

drozer-agent: 包含了运行于Android设备的Agent代码；

jdiesel：反射和通信协议的核心jar工程；

mwr-tls：安全通信jar工程；

mwr-android: 移动端界面jar工程；

2.    Drozer通信协议

       Drozer和Agent之间的通信采用google protocol buffer协议，这种协议是一种轻便高效的结构化数据存储格式，可以用于结构化数据串行化，很适合做数据存储或 RPC 数据交换格式。它可用于通讯协议、数据存储等领域的语言无关、平台无关、可扩展的序列化结构数据格式。目前提供了 C++、Java、Python 三种语言的 API。完整协议可以参见github（https://github.com/mwrlabs/mercury-common/blob/master/protobuf.proto）上的源码，该协议是两者协作的核心。

下面是对这个协议的简单介绍：

该协议中包含4种消息类型，其中包括SYSTEM_REQUEST、SYSTEM_RESPONSE、REFLECTION_REQUEST、REFLECTION_RESPONSE

message Message {
         enum MessageType {
                   SYSTEM_REQUEST= 1;
                   SYSTEM_RESPONSE= 2;
                   REFLECTION_REQUEST= 3;
                   REFLECTION_RESPONSE= 4;
         }
   }

SystemRequest:包含设备信息，会话信息，连接控制

message SystemRequest {
                   enum RequestType {
                            PING= 1;
                            BIND_DEVICE= 2;
                            UNBIND_DEVICE= 3;
                            LIST_DEVICES= 4;
                            START_SESSION= 5;
                            STOP_SESSION= 6;
                            RESTART_SESSION= 7;
                            LIST_SESSIONS= 8;
                       }
                   required RequestType type = 1 [default = PING];
                   optional Device device = 5;
                   optional string session_id = 7;
                   optional string password = 8;
     }

SystemResponse:主要包括响应的类型（绑定服务，设备列表，会话列表等）状态信息

message SystemResponse {
                   enum ResponseType {
                            PONG= 1;
                            BOUND= 2;
                            UNBOUND= 3;
                            DEVICE_LIST= 4;
                            SESSION_ID= 5;
                            SESSION_LIST= 6;
                   }

                   enum ResponseStatus {
                            SUCCESS= 1;
                            ERROR= 2;
                   }
                   required ResponseType type = 1;
                   required ResponseStatus status = 2;
                   repeated Device devices = 6;
                   optional string session_id = 7;
                   optional string error_message = 8;
                   repeated Session sessions = 9;
         }

ReflectionRequest:java反射请求，主要有Resolve(所反射的classname)，Construct(对象引用ObjectReference（int32类型），方法对象method，和方法参数Argument)，Invoke调用方法（同样包括对象引用ObjectReference（int32类型），方法对象method，和方法参数Argument），以及对Property的get与set，还有Delete(对象引用ObjectReference（int32类型）)

message ReflectionRequest {
                   enum RequestType {
                            RESOLVE= 1;
                            CONSTRUCT= 2;
                            INVOKE= 3;
                            SET_PROPERTY= 4;
                            GET_PROPERTY= 5;
                            DELETE= 6;
                            DELETE_ALL= 7;
                   }

                   required string session_id = 1;
                   required RequestType type = 2;

                   message Resolve {
                            optional string classname = 1;
                   }

                   message Construct {
                            optional ObjectReference object = 1;
                            repeated Argument argument = 2;
                   }

                   message Invoke {
                            optional ObjectReference object = 1;
                            optional string method = 2;
                            repeated Argument argument = 3;
                   }

                   message SetProperty {
                            optional ObjectReference object = 1;
                            optional string property = 2;
                            optional Argument value = 3;
                   }

                   message GetProperty {
                            optional ObjectReference object = 1;
                            optional string property = 2;
                   }

                   message Delete {
                            optional ObjectReference object = 1;
                   }

                   optional Resolve resolve = 3;
                   optional Construct construct = 4;
                   optional Invoke invoke = 5;
                   optional SetProperty set_property = 6;
                   optional GetProperty get_property = 7;
                   optional Delete delete = 8;
         }

ReflectionResponse:主要是反射响应后的状态和参数，还有一些错误信息

message ReflectionResponse {
                   enum ResponseStatus {
                            SUCCESS= 1;
                            ERROR= 2;
                            FATAL= 3;
                   }

                   required string session_id = 1;
                   required ResponseStatus status = 2;
                   optional Argument result = 3;
                   optional string errormessage = 8;
         }

3.    Drozer源码解析

        由于Drozer存在很多命令，在源码中会存在很多分支路径，本文不打算全部分析，主要侧重点在于我们常用的命令（连接Agent，运行模块）代码的分析，一般处理指令如下：

drozer console connect

run module_name argv

下面的内容就这两类命令的执行流程进行源码分析。

3.1 Drozer consoleconnect命令执行过程

     首先以drozer console connect为切入点。这条命令是Drozer端与Agent建立console会话。

Drozer端：

找到运行这条命令的入口点，入口点在drozer\cli\console.py

from mwr.common import logger
from drozer.console import Console
logger.setLevel(logging.DEBUG)
logger.addStreamHandler()

#实例化Console，并执行run()，这里取第3个及之后的参数，这里取的是connect
Console().run(sys.argv[2::])

在这个模块中，运行Console().run(sys.argv[2::])，Console这个类在drozer\console\console.py，这个类继承cli.Base（mwr\common\cli.py）。这个run()就在cli.Base这个类中实现，定位到cli.Base.run()：

def run(self, argv=None):
        if argv == None:
            argv = []
        
        self.prepare_argument_parser(argv)
        # parse argv into arguments using the generated ArgumentParser
        #解析命令行参数
        arguments = self.parse_arguments(self._parser, argv)
       #根据命令行参数调用对应的方法
        try:
            self.__invokeCommand(arguments)
        except UsageError as e:
            self.__showUsage(e.message)
        except Exception as e:
            self.handle_error(e)

继续跟踪__invokeCommand():

def __invokeCommand(self, arguments):
   
        try:
            command = arguments.command

            if “do_” + command in dir(self):
                #调用do_xxx方法
                getattr(self, “do_” + command)(arguments)
            else:
                raise UsageError(“unknown command: ” + command)
        except IndexError:
            raise UsageError(“incorrect usage”)

run()最后调用__invokeCommand()，通过getattr()调用do_xxx()，由于传入的参数connect，这里执行Console类里的do_connect()

def do_connect(self, arguments):
        if arguments.password:
            with warnings.catch_warnings():
                warnings.simplefilter(“ignore”)

                password = getpass.getpass()
        else:
            password = None
        #获取与Drozer绑定的设备
        device = self.__get_device(arguments)
        #获取与Agent连接的socket
        server = self.__getServerConnector(arguments)
        #获取与Agent开始会话的响应
        response = server.startSession(device, password)
        
        if response.type == Message.SYSTEM_RESPONSE and\
            response.system_response.status == Message.SystemResponse.SUCCESS:
            session_id = response.system_response.session_id

            try:
                if(arguments.debug):
                    session = DebugSession(server, session_id, arguments)
                else:
                     #与Agent建立会话
                    session = Session(server, session_id, arguments)

                if len(arguments.file) > 0:
                    session.do_load(” “.join(arguments.file))
                    session.do_exit(“”)
                elif arguments.onecmd != None:
                    session.onecmd(arguments.onecmd)
                    session.do_exit(“”)
                else:
                    #进入控制台，等待命令输入并执行
                    session.cmdloop()
            except KeyboardInterrupt:
                print
                print “Caught SIGINT, terminating your session.”
            finally:
                session.do_exit(“”)
                
            self.__getServerConnector(arguments).close()
        else:
            self.handle_error(RuntimeError(response.system_response.error_message), fatal=True)

这里主要是实现Drozer与Agent建立Session，进入控制台，等待命令的输入并执行。

下面根据drozer console connect这条命令的流程重点分析SystemRequest、ReflectionRequest两类消息的执行过程：

SystemRequest消息执行过程

device = self.__get_device(arguments)，这个方法获取与Drozer建立连接的设备。这里以这个分支详细分析SystemRequest消息的执行过程。定位到__get_device()：

def __get_device(self, arguments):

        if arguments.device == None:
            #获取与Drozer建立连接的设备
            devices = self.__getServerConnector(arguments).listDevices().system_response.devices

            if len(devices) == 1:
                device = devices[0].id

                print “Selecting %s (%s %s %s)\n” % (devices[0].id, devices[0].manufacturer, devices[0].model, devices[0].software)

             ……
             ……
            return arguments.device

__getServerConnector()是为了得到与Agent建立连接的socket。实现代码如下：

def __getServerConnector(self, arguments):

        if self.__server == None:
            #实例化ServerConnector类
            self.__server = ServerConnector(arguments, self.__manage_trust)

        return self.__server

ServerConnector这个类在drozer\connector\server_connector.py，核心代码是调用父类SocketTransport的__init__，从而获取与Agent的31415端口建立的socket。

class ServerConnector(SocketTransport):
    #连接的主机与端口
    DefaultHost = “127.0.0.1”
    DefaultPort = 31415
    
    def __init__(self, arguments, trust_callback=None):
        try:
             #调用SocketTransport.__init__，获取与Agent的31415端口建立的socket
            SocketTransport.__init__(self, arguments, trust_callback)
        ……
        ……

展开SocketTransport.__init__():

class SocketTransport(Transport):
    
    def __init__(self, arguments, trust_callback=None):
        Transport.__init__(self)
        #socket实例化
        self.__socket = socket.socket()
        
      ……
      ……

得到与agent建立连接的socket，接下来执行__getServerConnector(arguments).listDevices()定位到listDevices()：

def listDevices(self):

        try:
            #向Agent发送LIST_DEVICES消息并接收响应
            return self.sendAndReceive(SystemRequestFactory.listDevices())
        except RuntimeError as e:
            if e.message == ‘Received an empty response from the Agent. This normally means the remote service has crashed.’:
                raise ConnectionError(e)
            else:
                raise

这个方法调用sendAndReceive(SystemRequestFactory.listDevices())，而sendAndReceive主要是发送一个message给agent，并获取返回结果，定位到sendAndReceive：

def sendAndReceive(self, message):
         #为message加上一个id，然后将这个message封装为protocol buffer类型的Frame,最终发送给Agent
        message_id = self.send(message)

        while(True):
           #获取返回结果
            response = self.receive()

            if response == None:
                raise ConnectionError(RuntimeError(‘Received an empty response from the Agent.’))
            elif response.id == message_id:
                return response

展开send(message):

def send(self, message):
      
        try:
             #添加message id
            message_id = self.nextId()
            #封装为protocol buffer类对象
            frame = Frame.fromMessage(message.setId(message_id).build())
            #将消息发送给Agent
            self.__socket.sendall(str(frame))
    
            return message_id
      …..
      ……

我们再来看下此处message的细节。执行SystemRequestFactory.listDevices()，这个方法是为了获取与Drozer建立连接的Agent这样一个SystemRequest消息对象。定位到listDevices()：

def listDevices(cls):
         #实例化SystemRequest类型的对象
        builder = SystemRequestFactory(Message.SystemRequest.LIST_DEVICES)

        return builder

到这里，SystemRequest消息在Drozer中执行完毕。接下来看Agent是如何接收这个SystemRequest.LIST-DEVICES这个请求，并如何处理的。

Agent端：

       Agent首先会通过一个Receiver启动ServerService，这个ServerService就是与Drozer建立连接的服务。定位到Receiver：

public void onReceive(Context context, Intent intent) {
                   Intent start_service = new Intent();
                   start_service.putExtras(intent);         
                   if(intent.getCategories().contains(“com.mwr.dz.START_EMBEDDED”)){
                            start_service.addCategory(“com.mwr.dz.START_EMBEDDED”);

                            #Intent绑定ServerService
                            start_service.setComponent(new ComponentName(“com.mwr.dz”,
“com.mwr.dz.services.ServerService”));

                   }
                   else {
                            if(intent.getCategories().contains(“com.mwr.dz.CREATE_ENDPOINT”))
                                     start_service.addCategory(“com.mwr.dz.CREATE_ENDPOINT”);
                            if(intent.getCategories().contains(“com.mwr.dz.START_ENDPOINT”))
                                     start_service.addCategory(“com.mwr.dz.START_ENDPOINT”);                          
                            start_service.setComponent(new
ComponentName(“com.mwr.dz”, “com.mwr.dz.services.ClientService”));
                   }

                   #启动ServerService
                   context.startService(start_service);
         }

ServerService这个服务相对Drozer可以称为server端，主要负责监听Drozer的请求连接，并处理相关请求。

ServerService间接继承Service组件，onStartCommand()主要负责执行StartServer()这个方法。

public int onStartCommand(Intent intent, int flags, int startId){
                   int ret_val = super.onStartCommand(intent, flags, startId);
                   if(intent != null &&intent.getCategories() != null &&
intent.getCategories().contains(“com.mwr.dz.START_EMBEDDED”)) {
                            Agent.getInstance().setContext(this.getApplicationContext());

                            this.startServer();
                   }                 
                   return ret_val;
         }

定位到startServer()：

public void startServer() {
                   if(this.server == null) {
                            (new ServerSettings()).load(this.server_parameters);                         
                            this.server_parameters.enabled= true;

                           #实例化Server对象，其中Server类间接继承Thread
                            this.server = new Server(this.server_parameters, Agent.getInstance().getDeviceInfo());

                            this.server.setLogger(this.server_parameters.getLogger());
                            this.server_parameters.getLogger().addOnLogMessageListener(this);

                            #启动Server这个实例化线程，执行run()
                            this.server.start();       
                    
                           Toast.makeText(this,String.format(Locale.ENGLISH, this.getString(R.string.embedded_server_started),this.server_parameters.getPort()), Toast.LENGTH_SHORT).show();
                   }
         }

代码中的this.server是Server类的对象，这个Server类继承Link类，而Link类间接继承Thread，所以说，Server类是一个线程类。当执行this.server.start()时，这个线程就启动了。定位到Server类的run()。

public void run() {
                   this.running = true;                 
                   this.log(LogMessage.INFO,”Starting Server…”);
                   while(this.running) {
                            try {
                                     if(this.connection== null) {               
                                               this.log(LogMessage.INFO,”Attempting to bind to port ” +
((com.mwr.jdiesel.api.connectors.Server)this.parameters).getPort() +”…”);

                                                #实例化ServerSocket对象
                                               this.server_socket= new
ServerSocketFactory().createSocket((com.mwr.jdiesel.api.connectors.Server)this.parameters);

                                              this.log(LogMessage.INFO,”Waiting for connections…”);
                                               #接收Drozer的socket发送过来的请求
                                               Socket socket =this.server_socket.accept();
                                             
                                               if(socket!= null) {                                                                                                             
                                                        this.log(LogMessage.INFO,”Accepted connection…”);                                             
                                                        this.log(LogMessage.INFO,”Starting drozer thread…”);

                                                        #处理Drozer发过来的请求
                                                        this.createConnection(new SocketTransport(socket));
                                               }
                                     }

server_socket.accept()负责接收Drozer的请求。而createConnection(new SocketTransport(socket))负责处理这个请求。定位到createConnection()：

protected void createConnection(Transport transport) {
                   if(transport.isLive()) {
                            #实例化Connection对象
                            this.connection = new Connection(this,this.device_info, transport);   
     
                            this.connection.start();
                   }
         }

创建一个Connection实例，而后启动它。这个Connection也是间接继承Thread，也是一个线程类。定位到这个类的run()，而这个run()是继承来自它的父类AbstractConnection，真正负责接收Drozer的请求与处理相对应的请求就在这里实现的。具体代码如下：

public void run() {
                   this.running = true;
                   this.started = true;
                   this.tryAndNotifyAll();                
                   this.last_message_at =System.currentTimeMillis();                
                   Message request = null;                 
                   if(!this.bindToServer(this.device_info))
                            this.stopConnection();                   
                   while(this.running) {

                             #获取Drozer发送过来的request
                            request = this.receive();  
                        
                            if(request != null){

                                     #处理request
                                     this.handleMessage(request);                          
                                     request =null;
                            }                        
                            this.checkForLiveness();                          
                            Thread.yield();
                   }

展开this.receive()这个函数，将请求转化为Frame对象，这里需要将request转化为Frame对象，是不是符合Drozer将message封装成Frame的过程？定位到receive()：

protected Message receive() {
                   try {
                            #将request转化为Frame类型
                            Frame f = this.transport.receive();    
                     
                            return f != null ?f.getPayload() : null;
}             

再展开this.handleMessage()，代码如下：

private void handleMessage(Message message) {
                   try {
                            Message response = null;
                            switch(message.getType()){

                            case REFLECTION_REQUEST:
                                     response = this.handleReflectionRequest(message);
                                     break;

                            case REFLECTION_RESPONSE:
                                     response = this.handleReflectionResponse(message);
                                     break;

                            #匹配message类型，并做相应的处理
                            case SYSTEM_REQUEST:
                                     response = this.handleSystemRequest(message);
                                     break;

                            case SYSTEM_RESPONSE:
                                     response = this.handleSystemResponse(message);
                                     break;

                            default:
                                     throw new UnexpectedMessageException(message.getType());
                            }

                            #将处理后的结果返回给Drozer
                            if(response != null)
                                     this.send(response);
                   }

从这里可以看出，这里根据不同的消息类型进行处理。因为LIST_DEVICES属于SystemRequest，所以这个交给handleSystemRequest()处理。而handleSystemRequest()调用system_message_handler.handle()进行处理。而后将response返回给Drozer。

展开system_message_handler.handle()，system_message_handler属于SystemMessageHandler的实例。Handle()代码如下：

public Message handle(Message message) throws InvalidMessageException {
                   if(message.getType() != Message.MessageType.SYSTEM_REQUEST)
                            throw new InvalidMessageException(message);
                   if(!message.hasSystemRequest())
                            throw new InvalidMessageException(message);
                   switch(message.getSystemRequest().getType()){

                   #匹配具体的SystemRequest消息类型，并进行处理
                   case LIST_DEVICES:
                            return this.handleListDevices(message);
                   case LIST_SESSIONS:
                            return this.handleListSessions(message);                           
                   case PING:
                            return this.handlePing(message);                            
                   case START_SESSION:
                            return this.startSession(message);                           
                   case STOP_SESSION:
                            return this.stopSession(message);                          
                   default:
                            throw new InvalidMessageException(message);
                   }

到这里就看到LIST_DEVICES消息类型了。定位到handleListDevices()

protected Message handleListDevices(Message message) throws InvalidMessageException {
                   MessageFactory factory = new MessageFactory(SystemResponseFactory.deviceList(message).addDevice(
                                     this.device_info.getAndroidID(),
                                     this.device_info.getManufacturer(),
                                     this.device_info.getModel(),
                                     this.device_info.getSoftware()));                   
                   factory.inReplyTo(message);     
           
                   return factory.build();
         }

至此，整个获取与Drozer建立连接的设备就结束了。

接着往下走，下面重点分析

ReflectionRequest消息执行过程

现在我们重点分析建立会话过程，定位到Console.do_connect():

def do_connect(self, arguments):
        if arguments.password:
            with warnings.catch_warnings():
                warnings.simplefilter(“ignore”)

                password = getpass.getpass()
        else:
            password = None
        #获取与Drozer绑定的设备
        device = self.__get_device(arguments)
        #获取与Agent连接的socket
        server = self.__getServerConnector(arguments)        
        #获取与Agent开始会话的响应
        response = server.startSession(device, password)
        
        if response.type == Message.SYSTEM_RESPONSE and\
            response.system_response.status == Message.SystemResponse.SUCCESS:
            session_id = response.system_response.session_id

            try:
                if(arguments.debug):
                    session = DebugSession(server, session_id, arguments)
                else:                    
                     #与Agent建立会话
                    session = Session(server, session_id, arguments)

                if len(arguments.file) > 0:
                    session.do_load(” “.join(arguments.file))
                    session.do_exit(“”)
                elif arguments.onecmd != None:
                    session.onecmd(arguments.onecmd)
                    session.do_exit(“”)
                else:                   
                     #进入控制台，等待命令输入并执行
                    session.cmdloop()
            except KeyboardInterrupt:
                print
                print “Caught SIGINT, terminating your session.”
            finally:
                session.do_exit(“”)
                
            self.__getServerConnector(arguments).close()
        else:
            self.handle_error(RuntimeError(response.system_response.error_message), fatal=True)

我们从这行入手session = Session(server, session_id, arguments)，初始化session对象，建立与Agent联系的session。

定位到Session类的__init__方法：

class Session(cmd.Cmd):

    def __init__(self, server, session_id, arguments):
        cmd.Cmd.__init__(self)
        self.__base = “”
        self.__has_context = None
        self.__module_pushed_completers = 0
        self.__permissions = None
        self.__server = server
        self.__session_id = session_id
        self.__onecmd = arguments.onecmd
        self.active = True
        self.aliases = { “l”: “list”, “ls”: “list”, “ll”: “list” }
        self.intro = “drozer Console (v%s)” % meta.version
        self.history_file = os.path.sep.join([os.path.expanduser(“~”), “.drozer_history”])
        #模块集
        self.modules = collection.ModuleCollection(loader.ModuleLoader())
        self.prompt = “dz> “
        #反射对象
        self.reflector = Reflector(self)
        if hasattr(arguments, ‘no_color’) and not arguments.no_color:
            self.stdout = ColouredStream(self.stdout)
            self.stderr = ColouredStream(self.stderr)
        else:
            self.stdout = DecolouredStream(self.stdout)
            self.stderr = DecolouredStream(self.stderr)

        #实例化Module对象m
        m = Module(self)

        if m.has_context():
            #如果Context不存在，获取com.mwr.dz.Agent的数据路径，得到的路径是/data/data/com.mwr.dz.Agent
            dataDir = str(m.getContext().getApplicationInfo().dataDir)
        else:
            dataDir = str(m.new(“java.io.File”, “.”).getCanonicalPath().native())

        self.variables = {  ‘PATH’: dataDir +’/bin:/sbin:/vendor/bin:/system/sbin:/system/bin:/system/xbin’,
                            ‘WD’: dataDir }
        
        self.__load_variables()
        
        if arguments.onecmd == None:
            self.__print_banner()

如果Context不存在，获取com.mwr.dz.Agent的数据路径，当然这里就要用到消息反射了。定位到Modules的getContext()：

def getContext(self):
         #利用反射得到com.mwr.dz.Agent的实例
        return self.klass(‘com.mwr.dz.Agent’).getContext()

继续跟踪klass()

def klass(self, class_name):

        if not Module.cached_klass(class_name):
             #存储反射引用到cache中
            Module.cache_klass(class_name, self.reflector.resolve(class_name))
        
        return Module.get_cached_klass(class_name)

继续执行会跳转到Reflector.resolve方法：

def resolve(self, class_name):
          #将反射请求发送到Agent
        response = self.sendAndReceive(ReflectionRequestFactory.resolve(class_name))

        if response is None:
            raise ReflectionException(“expected a response to RESOLVE”)
        elif response.reflection_response.status == Message.ReflectionResponse.SUCCESS:
            return ReflectedType.fromArgument(response.reflection_response.result, reflector=self)
        else:
            raise ReflectionException(response.reflection_response.errormessage)

到这里，我们又看到SendAndReceive()，接下来的执行过程可参考Drozer端的SystemRequest消息的执行过程。

Agent端：

Agent接收与处理ReflecionRequest类消息可参考上节讲的SystemReqeust。这里重点讲下ReflectionRequest的处理过程。最终执行过程如下：

public Message handle(Message message) throws InvalidMessageException {
                   if(message.getType() != Message.MessageType.REFLECTION_REQUEST)
                            throw new InvalidMessageException(message);
                   if(!message.hasReflectionRequest())
                            throw new InvalidMessageException(message);
                   try {
                            switch(message.getReflectionRequest().getType()){
                            case CONSTRUCT:
                                     if(!message.getReflectionRequest().hasConstruct())
                                              throw new InvalidMessageException(message);                                   
                                     return this.handleConstruct(message);                                   
                            case DELETE:
                                     if(!message.getReflectionRequest().hasDelete())
                                               throw new InvalidMessageException(message);                                    
                                     return this.handleDelete(message);                                    
                            case DELETE_ALL:
                                     return this.handleDeleteAll(message);                                   
                            case GET_PROPERTY:
                                     if(!message.getReflectionRequest().hasGetProperty())
                                               throw new InvalidMessageException(message);                                    
                                     return this.handleGetProperty(message);                                   
                            case INVOKE:
                                     if(!message.getReflectionRequest().hasInvoke())
                                               throw new InvalidMessageException(message);                                 
                                     return this.handleInvoke(message);

                            #执行resolve类的ReflectionRequest消息
                            case RESOLVE:
                                     if(!message.getReflectionRequest().hasResolve())
                                               throw new InvalidMessageException(message)  
                                  
                                     return this.handleResolve(message);
                            case SET_PROPERTY:
                                     if(!message.getReflectionRequest().hasSetProperty())
                                               throw new InvalidMessageException(message);
                                     return this.handleSetProperty(message);
                            default:
                                  throw new InvalidMessageException(message);
                            }
                   }

定位到handResolve():

protected Message handleResolve(Message message) throws InvalidMessageException {
                  #利用反射得到类的class
                  Class<?>klass =
Reflector.resolve(message.getReflectionRequest().getResolve().getClassname());

                   if(klass != null) {
                            int ref = this.session.object_store.put(klass);
                            return this.createResponse(message,   ReflectionResponseFactory.object(ref));
                  }
                   else {
                            return this.handleError(message, “cannot resolve ” +
message.getReflectionRequest().getResolve().getClassname());
                   }
         }

定位到Reflector.resolve：

public static Class<?> resolve(String className) {
                   try {
                            #反射得到类名的class
                            return Class.forName(className);
                   }
                   catch(ClassNotFoundException e) {
                            return null;
                   }
         }

至此，ReflectonRequest整个请求与处理过程完成了。

3.2 runmodule_name argvs命令执行过程

为了方便，这里以run app.package. AttackSurface packageName为例说明。

现在我们重点分析在console中执行命令的过程，定位到Console.do_connect():


def do_connect(self, arguments):
        if arguments.password:
            with warnings.catch_warnings():
                warnings.simplefilter(“ignore”)

                password = getpass.getpass()
        else:
            password = None
        #获取与Drozer绑定的设备
        device = self.__get_device(arguments)
        #获取与Agent连接的socket
        server = self.__getServerConnector(arguments)        
        #获取与Agent开始会话的响应
        response = server.startSession(device, password)
        
        if response.type == Message.SYSTEM_RESPONSE and\
            response.system_response.status == Message.SystemResponse.SUCCESS:
            session_id = response.system_response.session_id

            try:
                if(arguments.debug):
                    session = DebugSession(server, session_id, arguments)
                else:                    
                     #与Agent建立会话
                    session = Session(server, session_id, arguments)

                if len(arguments.file) > 0:
                    session.do_load(” “.join(arguments.file))
                    session.do_exit(“”)
                elif arguments.onecmd != None:
                    session.onecmd(arguments.onecmd)
                    session.do_exit(“”)
                else:                   
                     #进入控制台，等待命令输入并执行
                    session.cmdloop()
            except KeyboardInterrupt:
                print
                print “Caught SIGINT, terminating your session.”
            finally:
                session.do_exit(“”)
                
            self.__getServerConnector(arguments).close()
        else:
            self.handle_error(RuntimeError(response.system_response.error_message), fatal=True)

此处从session.cmdloop()入手，定位到cmdloop()方法：

def cmdloop(self, intro=None):
        self.preloop()
        if self.use_rawinput and self.completekey:
            self.push_completer(self.complete, self.history_file)
        try:
            stop = None
            while not stop:
                if self.cmdqueue:
                    line = self.cmdqueue.pop(0)
                else:
                    if self.use_rawinput:
                        try:
                           #得到用户输入的命令
                            line = raw_input(self.prompt)
                        except EOFError:
                            line = ‘EOF’
                    else:
                        self.stdout.write(self.prompt)
                        self.stdout.flush()
                        line = self.stdin.readline()
                        if not len(line):
                            line = ‘EOF’
                        else:
                            line = line.rstrip(‘\r\n’)
                            
                try:
                    line = self.precmd(line)
                     #解析输入的命令
                    stop = self.onecmd(line)
                    stop = self.postcmd(stop, line)
               …..
               …..

这里首先获取用户的输入命令，然后执行onecmd()对获取到的命令进行解析。定位到onecmd()：

def onecmd(self, line):
        cmd, arg, line = self.parseline(line)
        if not line:
            return self.emptyline()
        if cmd is None:
            return self.default(line)
        self.lastcmd = line
        if line == ‘EOF’ :
            self.lastcmd = ”
        if cmd == ”:
            return self.default(line)
        else:
            try:
                #获取console当中的命令，调用do_xxx
                func = getattr(self, ‘do_’ + cmd)
            except AttributeError:
                return self.default(line)
            return func(arg)

这里，根据输入的命令跳转到对应do_xxx的方法进行解析。

此处分析 run命令的执行过程，定位到Session.do_run()方法：

def do_run(self, args):     
        argv = shlex.split(args, comments=True)

        if len(argv) == 1 and (argv[0] == “-h” or argv[0] == “–help”):
            self.do_help(“run”)
            return

        if len(argv) > 0:
            try:
                 #解析run语句后面的第一个参数，这个参数决定调用哪个module，此处这个module指的是app.package. AttackSurface
                module = self.__module(argv[0])
                module.push_completer = self.__push_module_completer
                module.pop_completer = self.__pop_module_completer
                
                self.__module_pushed_completers = 0
            except KeyError as e:
                self.stderr.write(“unknown module: %s\n” % str(e))
                return None

            try:
                 #调用module.run()，这里argv[1:]指的packageName
                module.run(argv[1:])
            except KeyboardInterrupt:
                self.stderr.write(“\nCaught SIGINT. Interrupt again to terminate you session.\n”)
            except Exception as e:
                self.handleException(e)
            
            while self.__module_pushed_completers > 0:
                self.__pop_module_completer()
        else:
            self.do_help(“run”)

因为所以的modules都继承Module，而module.run()这个run()是在Module中实现的，定位到Module.run()：

 def run(self, args):
   
         #实例化parse对象
        parser = self.__prepare_parser()

        parser.description = self.usage.formatted_description()
        parser.usage = self.usage.formatted_usage(parser)

        if “-h” in args or “–help” in args:
            return parser.print_help()
        else:
             #获取命令行参数
            arguments = parser.parse_args(args)
            
            if hasattr(self, ‘execute’):
                 #执行app.package. AttackSurface中的execute()
                result = self.execute(arguments)
            else:
                self.stderr.write(“drozer doesn’t know how to do that.\n”)
                self.stderr.write(“The %s module does not define an execute() method.\n\n” % self.fqmn())
                
                result = None
                
            self.clearObjectStore()

            return result

定位到app.package. AttackSurface.execute():

def execute(self, arguments):
        if arguments.package != None:
            package = self.packageManager().getPackageInfo(arguments.package, common.PackageManager.GET_ACTIVITIES | common.PackageManager.GET_RECEIVERS | common.PackageManager.GET_PROVIDERS | common.PackageManager.GET_SERVICES)
            application = package.applicationInfo

            activities = self.match_filter(package.activities, ‘exported’, True)
            receivers = self.match_filter(package.receivers, ‘exported’, True)
            providers = self.match_filter(package.providers, ‘exported’, True)
            services = self.match_filter(package.services, ‘exported’, True)
            
            self.stdout.write(“Attack Surface:\n”)
            self.stdout.write(”  %d activities exported\n” % len(activities))
            self.stdout.write(”  %d broadcast receivers exported\n” % len(receivers))
            self.stdout.write(”  %d content providers exported\n” % len(providers))
            self.stdout.write(”  %d services exported\n” % len(services))

            if (application.flags & application.FLAG_DEBUGGABLE) != 0:
                self.stdout.write(”    is debuggable\n”)

            if package.sharedUserId != None:
                self.stdout.write(”    Shared UID (%s)\n” % package.sharedUserId)
        else:
            self.stdout.write(“No package specified\n”)

至此，在console当中run命令的执行分析过程就结束了。

4.    Drozer小结

      Drozer可以看成是C/S结构的工具。PC端是用Python写的，Agent端是用java写的。利用Google Protocol Buffer协议作为消息载体。很重要的一点就是利用反射，很大一部分工作都是由Agent代理完成，最后由PC端处理解析。后面还有就是命令的具体实现部分，后面会陆续更新。

5.    参考链接

 http://www.freebuf.com/articles/terminal/111863.html

 http://bbs.pediy.com/showthread.php?t=190561

    原文作者：Android源码分析
    原文地址: https://blog.csdn.net/itlance_ouyang/article/details/52486754
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞