自搭的基于Frida一体化采集框架

提示：本文仅分享框架设计思路和大体的使用，全是博主自己个人的设计思路，转载请注明出处

---

前言

随着自己做逆向采集已经快一年了，逆向的方向还是半桶水，但是优化采集流程，搭建自己的采集体系方便工作和运维却是在这一年中有较大的提升。本框架就提供一个学习思路和大体的使用，所有的一些操作都是博主个人经验的总结，用代码的形式展现出来而已，细节方面还得靠自己去看代码跟着思路走。下文中的cpfirda就是本次的框架，是基于frida进行的二次开发，好，下面进入正文，害怕起来了。。。。。。

---

一、cpfrida的功能

简单用一句话来说：搭好架构，完善hook脚本，配置好项目配置，手机直接接入，就可以采集数据

1.日志收集

提供了简易的日志收集，用来记录每次hook的数据、数据回传、对设备的操作以及一些异常信息的收集等等，用来分析一个完整的hook流程或者分析hook过程中的一些异常，方便后续优化流程等操作

2.设备操作

提供了简易的运维操作，因为在hook的时候设备或系统的原因，会导致app经常卡死，这时候就有重启手机或者app等简单的操作来保持hook流程的正常进行

3.异常告警

提供了一些消息通知，正常的一个项目，肯定要有自己的告警体系，这边我采用了飞书群通知的形式告知运维人员设备风控等情况，至于要其他形式，需要自己找api接入

4.模板处理

提供了模板快速生成代码的功能，为什么要这个呢？有做过frida采集的同学一定深有体会，frida是用脚本的形式去打桩的，每次脚本可能都不大一样，但是总体又可能相似，就差一些参数或者频率等等，这时候模板就会帮助我们去节省大量的开发时间了

5.进程维护

提供了进程维护功能，frida是脚本形式就奠定了它比较难以有效的集中管理，通常是以脚本的形式运行业务，那一些奇奇怪怪的问题就会导致脚本停止，这时候就需要在脚本运行的时候记录一下当前脚本的进程信息，方便后续运维

6.自动运维

提供了简单的自动运维功能，当脚本停止，数据长时间没有回调，我们是需要一个数据回调的统计和告警平台的，当数据长时间未回调，这个平台上的对应信息就会出现一个告警（这个流程也比较简单，就是监控数据回调的时长，如果超过某个值没有数据回传，那么就认为设备异常，出告警就行了），然后框架会定时去访问这个平台，捕获到告警信息，对对应的设备进行重启等操作，如果框架有在运维对应的进程，就会杀死对应的进程，重新在创建一个新的进程（为什么要杀死？因为如果那个进程还在的话没有什么问题，只是在等待hook的参数，那么当没有杀死进程的情况下，一旦拿到了hook参数，那么此时就有两条进程在同时跑一个设备一个app的打桩点，目前以我的经验这样是行不通的）

7.快速生成项目

基于第四个模板处理下，框架提供了根据配置文件快速生成项目的功能，说白了就是项目开始自有配置文件，框架会根据配置项生成不同的工作空间（这个后续在讲什么是工作空间）来完善整个项目。当然还提供了收纳项目了，会根据框架中你可能手动改过的配置进行更新已有的配置，同时删除了对应的工作空间，这样项目的可移植性非常之高了

8.频率可调控

做爬虫的或者逆向采集的，都知道频率是个很玄学的东西，我们会经常去修改频率来满足我们的业务需求或者来规避风控等等，该框架集成了一些采集的频率，我们可以通过认为的方式去调控频率，但不是实时的，需要停止该业务线在启动才生效（如果实时的我觉得IO应该会比较高。。。。。。）

9.服务端快速部署

提供了一快速部署项目的脚本，如果用Jenkins的话，拉玩代码执行该脚本就行，如果手动的也是一样，十分方便

10.hook脚本的雏形（自己编写hook逻辑）

集成了一些hook过程常用的工具，需要手动拉起对应的dex包到手机的/data/loacl/tmp目录，只有这个目录用户才有操作的权限

11.手机端快速部署（自己实现）

这个我就给个思路吧，这个地方比较复杂，我们开发一个APP，这个APP有什么功能呢？
a、可以发送广播，这个广播可以启动内网穿透对应的程序和frida服务端的程序，而且要实时运行，这样就可以完全打通服务端和手机端的正常通信了
b、这个APP可以释放对应项目所需的dex包和frida-server包以及你们自己的一些脚本啊等的
c、这个APP可以拉起内网穿透程序配置，这个配置是把frida端口和ADB端口映射到服务端的，这样能方便我们工作，手机中去编辑配置，想想都蛋疼。。。。。。

二、宏观看架构

上面介绍完了功能，现在我们来看看项目的整体流程，直接上流程图：

这张图片是最早之前自己画的流程图，其中还包括了开发部分，很简单明了，相信一看就到明白了。传统的Frida在本地调试的时候需要用usb连接，我框架中直接采用远程连接，然后利用frp内网穿透工具把frida的端口和ADB的端口直接都映射到Linux服务器上，这样就可以直接在服务器上的某个端口访问手机端的frida端口和ADB端口实现远程操作了，像之前如何将手机变成一个（Linux）服务器提到的在手机上安装Linux服务，非常之不稳定和繁琐，这样做的稳定性和简便我自己是深有体会的

三、微观看架构

1.服务端环境

先上图：
a、python3.8：为了兼容frida15.1.10版本，这里我选用Anaconda3
b、frida-client：对于手机来说，此时linux就是客户端，frida对应的插件可以网上找一大堆，这里就不赘述了，我选用的是葫芦娃大佬编译的frida
c、adb工具：远程操作手机和app，网上一堆
d、frp-server：映射手机上的frida和adb端口的，网上都有，其他工具只要能实现内网穿透都行
e、linux自带的定时任务crontab：用来定时启动监控脚本，在项目启动文件中已经写好了

2.手机端环境

先上图：

a、fastjson.dex：阿里开发的对象和JSON的处理包
b、FRP_INSTALL_YouWant：自己开发的APP用来发送广播，维护frida和frp的app
c、helper：自己开发的JONS处理工具，删除JSON不需要的字段
d、Magisk：获取手机的root权限，在刷机的时候刷入，可以去玩主页学习怎么刷机点击学习
e、RootExplorer：文件管理工具，系统自带的不好用

3.辅助环境

这里的辅助指的是一件部署功能的，即jenkins，详细的部署流程和简单的使用可以去我主页看对应的博文点击学习

你也许会觉得上面的插件和APP怎么这么多啊，这个就看你自己规划了，可以根据自己的认知简易部署流程，或者可以舍弃一些自己觉得没用的东西，毕竟有些东西是辅助作用，不是项目的核心需要哈

四、代码详解

1.项目目录

项目目录这个东西啊，真的有些头疼，开发的小伙伴也行会感同身受，本项目的目录大部分以及配置好了，无需太多的改动，上项目目录图：

cpfrida：项目名称

v1.0：版本，和v2.0采集逻辑上不同，v1.0是采用权限分发的形式，怎么分发的呢？这么说吧，你自顾自的采集会导致数据失衡，满足不了业务，所有规则就是满足业务需求，举个例子：比如有几个接口detail、product、live、topic，业务需要的是detail一个，product三个，live五个，topic两个，这时候假设你要部署11个设备上去满足业务，但是在采集的过程中，你会发现某一天product数据量过多，在规定时间内完成不了，但是呢，live数据量过少很大一部分时间会处于空闲时间，这样就相当于浪费了资源，于是就有了权限分发，每台设备先按之前的方式部署好，detail一个，product三个，live五个，topic两个，当某台设备空闲的时候就会执行下级权限，现在live的设备权限顺序为：live–>product–>detail–>topic，当live空闲的时候，它就执行product，product也空闲的时候依次类推，每次完成一次完整的hook之后，权限又是重头开始，这样做就可以达到资源全部合理利用啦，对了，牢记frida无法同时在一个点打桩多次，按我hook的app来看的话是这样，上面的权限分发就有效的避开了这个问题

v2.0：版本，和v1.0采集逻辑上不同，v2.0是采用进程池的概念，它比一来的简单暴力，但是业务线过多的话Linux服务器可能就需要多个了，比较耗费一些资源。它没有那些采集规则，业务不够就加一套，还是接口detail、product、live、topic，一样的部署方式，只是此时11个设备我每个设备都跑四条业务，这时候就有44个业务了，是不是体量多太多了，想想都有点小刺激

common：一些通用模块

• build_model.py：项目配置文件模块
• handle_template.py：模板生成代码核心
• ident_model.py：工作空间标识
• inform_mode.py：消息通知模块，对接群机器人等api
• logging_mode.py：日志模块
• phone_model.py：手机操作模块
• process_model.py：进程管理模块

deploy：快速生成项目相关，已经封装在项目部署文件中

• template：代码模板

  • config_template：每个工作空间的配置项
  • startwork_template：工作空间启动项，sh
  • workspace_template：工作空间代码

• build.ini：项目配置项，所有的工作空间都是根据这个配置项生成的

• build_.ini：配置项的各项说明

• deploy.py：快速生成代码的核心，已集成到项目启动脚本中

hookscript：hook脚本js代码

• vx_hooker_8015.js：hook代码的逻辑，已经封装好了一些常用的工具
• vx_hooker_8018.js：hook代码的逻辑，已经封装好了一些常用的工具

startproject：项目部署启动相关

• kill_process.py：杀死当前系统下的说有python进程，所有建议服务器单一点就跑这个采集框架，v2.0是这样的，v1.0比较智能，是根据进程管理来进行kill的，也可能错杀，当没有v2.0这么暴力
• reboot_phone.py：重启所有的设备，多进程模式重启
• start_project.py：解压项目启动脚本，sh，因为直接sh通过jenkins部署会存在编码问题

workspace：工作空间

工作空间下自由的模块：

• monitor：监控模块
  • monitor.py：监控基类，封装好了一些常用方法和操作
  • monitor.py：继承监控基类，是点对点的，专属我自己的一个监控，可以自行编写哈
• base_script.py：frida的核心创建逻辑、对外部分交互和用到的模块载入
• business.py：hook的业务逻辑和send数据处理
• extend.py：项目的扩展功能，比如收集cookie，或者网页端采集等等
• params.py：项目用到的固有参数，和一些任务常调控的参数，比如频率
• device1：工作空间（设备名称），这个是根据build.ini生成出来的，一个完整的工作空间是有：
  • 配置文件 config.py，对应的配置项都有对应的说明
  • 工作者 device1.py，单个进程或进程池的入口
  • 工作空间启动项 device1.sh，值适用linux系统，window系统可以直接手动输入指令执行或者在IDE中执行
  • 工作空间身份 uuid

requirements.txt：项目依赖

2.javascript核心代码

不会反编译，一切都是徒劳的，下面就给出了js的辅助工具，至于hook的核心代码和接口，这边不便展示，懂得都懂（手动狗头）：

/**
 * @Description: Wechat 8015 hook script
 * @author XQE
 * @date 2022/04/19
*/


var tools = {
    classexists: function (className) {
        var _exists = false
        try {
            Java.use(className)
            _exists = true
        } catch (err) {
        }
        return _exists
    },

    checkloaddex: function (className, dexfile) {
        if (!this.classexists(className)) {
            Java.openClassFile(dexfile).load()
        }
    },

    tojsonstring: function (obj) {
        try {
            this.checkloaddex("com.alibaba.fastjson.JSON", "/data/local/tmp/fastjson.dex")
            var _clz = Java.use("com.alibaba.fastjson.JSON")
            var _toJSONStringMehtod = _clz.toJSONString.overload("java.lang.Object")
            return _toJSONStringMehtod.call(_clz, obj)
        } catch (err) {
            console.log(err)
        }
        return "{}"
    },

    fromjsonstring: function (jsonStr, classObj = null) {
        try {
            this.checkloaddex("com.alibaba.fastjson.JSON", "/data/local/tmp/fastjson.dex")
            if (classObj == null) {
                var _clz = Java.use("com.alibaba.fastjson.JSON")
                return _clz.parseObject(jsonStr)
            } else {
                var _jsonObject = Java.use("com.alibaba.fastjson.JSONObject")
                var _obj = _jsonObject.parseObject(jsonStr, classObj.class)
                return _obj
            }
        } catch (err) {
            console.log(err)
        }
        return null
    },

    recursionremove: function (jsonObject, removeKey) {
        var _keyArray = jsonObject.keySet().toArray()
        for (var i = 0; i < _keyArray.length; i++) {
            var _key = _keyArray[i]
            var _object = jsonObject.get(_key)
            var _objectType = ""
            try {
                _objectType = _object.getClass().getName()
            } catch (e) {}
            if (_key == removeKey && _objectType == "java.lang.String") {
                jsonObject.remove(_key)
            }
            if (_objectType == "com.alibaba.fastjson.JSONObject") {
                this.recursionremove(jsonObject.getJSONObject(_key), removeKey)
            }
            if (_objectType == "com.alibaba.fastjson.JSONArray") {
                var jsonArray = jsonObject.getJSONArray(_key)
                for (var a = 0; a <= jsonArray.size(); a++) {
                    try {
                        var _childObj = jsonArray.getJSONObject(a)
                        if (_childObj) {
                            this.recursionremove(_childObj, removeKey)
                        }
                    } catch (e) {
                        console.log(e)
                    }
                }
            }
        }
    },

    wxhelper: function () {
        try {
            this.checkloaddex("com.alibaba.fastjson.JSON", "/data/local/tmp/fastjson.dex")
            this.checkloaddex("com.tencent.mm.wechathelperdex.WxHelper", "/data/local/tmp/wxhelper.dex")
            var _clz = Java.use("com.tencent.mm.wechathelperdex.WxHelper")
            return _clz
        } catch (err) {
            console.log(err)
        }
        return "{}"
    },

    hashset: function () {
        var _HashSetClz = Java.use("java.util.HashSet")
        var _hashset = _HashSetClz.$new()
        return _hashset
    },

    map: function () {
        var _hashMap_clz = Java.use("java.util.HashMap")
        var _map_clz = Java.use("java.util.Map")
        var _hashMap = _hashMap_clz.$new()
        var _map = Java.cast(_hashMap, _map_clz)
        return _map
    },

    base64: function (zsBase64) {
        var androidBase64 = Java.use("android.util.Base64")
        var _base64 = androidBase64.decode(zsBase64, 0)
        return _base64
    },
}

var hooker_fun = {
    runComment: function (device, reply, args) {},

    runDetailVideo: function (device, args) {},

    runDetailGoods: function (device, args) {},

    runLiveInfo: function (device, username, args) {},

    runLiveBarrage: function (device, username, args) {},
	
	runLiveContribution: function(device, username, args) {},

    runLiveGoods: function (device, username, args) {},

    runLiveSquare: function (device, cate) {},

    runLiveTab: function () {},

    runLiveBag: function (device, args) {},

    runProductList: function (device, selfappid, args) {},

    runProductInfo: function (device, selfappid, args) {},

    runProductStore: function (device, selfappid, args) {},

    runProductTakecenter: function (device, selfappid, cookie, args) {}

    runProductThird: function (device, selfappid, cookie, args) {},

    runGetcookie: function (device, username) {},

    runTopicTopic: function (device, args) {},

    runTopicActivity: function (device, tab, args) {},

    runVideoGoods: function (device, args) {},
    
    runVideoUrl: function (device, args) {},
}

rpc.exports = {
    hookerVideoComment: function (device, reply, args) {
        Java.perform(function () {
            hooker_fun.runComment(device, reply, args)
        })
    },

    hookerDetailVideo: function (device, args) {
        Java.perform(function () {
            hooker_fun.runDetailVideo(device, args)
        })
    },

    hookerDetailGoods: function (device, args) {
        Java.perform(function () {
            hooker_fun.runDetailGoods(device, args)
        })
    },

    hookerLiveInfo: function (device, username, args) {
        Java.perform(function () {
            hooker_fun.runLiveInfo(device, username, args)
        })
    },

    hookerLiveBarrage: function (device, username, args) {
        Java.perform(function () {
            hooker_fun.runLiveBarrage(device, username, args)
        })
    },

    hookerLiveContribution: function (device, username, args) {
        Java.perform(function () {
            hooker_fun.runLiveContribution(device, username, args)
        })
    },

    hookerLiveGoods: function (device, username, args) {
        Java.perform(function () {
            hooker_fun.runLiveGoods(device, username, args)
        })
    },

    hookerLiveSquare: function (device, cate) {
        Java.perform(function () {
            hooker_fun.runLiveSquare(device, cate)
        })
    },

    hookerLiveTab: function () {
        Java.perform(function () {
            hooker_fun.runLiveTab()
        })
    },

    hookerLiveBag: function (device, args) {
        Java.perform(function () {
            hooker_fun.runLiveBag(device, args)
        })
    },

    hookerProductList: function (device, selfappid, args) {
        Java.perform(function () {
            hooker_fun.runProductList(device, selfappid, args)
        })
    },

    hookerProductInfo: function (device, selfappid, args) {
        Java.perform(function () {
            hooker_fun.runProductInfo(device, selfappid, args)
        })
    },

    hookerProductStore: function (device, selfappid, args) {
        Java.perform(function () {
            hooker_fun.runProductStore(device, selfappid, args)
        })
    },

    hookerProductTakecenter: function (device, selfappid, cookie, args) {
        Java.perform(function () {
            hooker_fun.runProductTakecenter(device, selfappid, cookie, args)
        })
    },

    hookerProductThird: function (device, selfappid, cookie, args) {
        Java.perform(function () {
            hooker_fun.runProductThird(device, selfappid, cookie, args)
        })
    },

    hookerGetcookie: function (device, username) {
        Java.perform(function () {
            hooker_fun.runGetcookie(device, username)
        })
    },

    hookerTopicTopic: function (device, args) {
        Java.perform(function () {
            hooker_fun.runTopicTopic(device, args)
        })
    },

    hookerTopicActivity: function (device, tab, args) {
        Java.perform(function () {
            hooker_fun.runTopicActivity(device, tab, args)
        })
    },

    hookerVideoGoods: function (device, args) {
        Java.perform(function () {
            hooker_fun.runVideoGoods(device, args)
        })
    },

    hookerVersionCheck: function () {
        Java.perform(function () {
            hooker_fun.runVersionCheck()
        })
    },

    hookerVideoUrl: function (device, args) {
        Java.perform(function () {
            hooker_fun.runVideoUrl(device, args)
        })
    },
}

讲解：
从代码中我们可以看到总体有三部分：

• tools：封装了一些常用的工具，其中包括
  • classexists：判断某个引用类是否存在
  • checkloaddex：加载dex包
  • tojsonstring：对象转json
  • fromjsonstring：json转对象
  • recursionremove：js层面删除json某个字段
  • wxhelper：java层面删除json某个字段，比js快
  • hashset：创建hashset容器
  • map：创建map容器
  • base64：字符串转android的base64
• hooker_fun：hook的逻辑实现处，这里仁者见仁智者见智，自行发挥，这部分太核心了，不方便展示
• rpc.exports：rpc远程调用，这个是一种写法，网上还有蛮多写法的，可以自行查阅，要注意的是这里的函数名要和python里的frida名称一致，但是比如hookerVideoComment，python里面要这样的hooker_video_comment

3.python的核心代码

A、business：采集流程控制核心

# !/usr/bin/env python
# coding=utf-8
# @Time    : 2022/04/20
# @Author  : XQE
# @Software: PyCharm


import os
import sys
import time
import json
import random
import config
import requests
sys.path.append("../common")
sys.path.append("../../common")
from extend import Extend
from base_script import BaseScript
from inform_model import Inform


class AdapterBusiness(Extend, BaseScript, Inform):
    """
    对hook业务进行适配，分发到对应的业务链上进行hook
    """
    Adapter = dict()

    def __init__(self, filename, device, url, full_path=""):
        Extend.__init__(self)
        BaseScript.__init__(self, filename, device, url, full_path)
        Inform.__init__(self, config.inform_url)
        for i in dir(self):
            self.Adapter[i] = getattr(self, i)

    def hooker_video_url(self):
        """
        hook视频播放地址
        """
        self.frida_object.exports.hooker_video_url(
            self.device,
            self.get_response
        )

    def hooker_video_goods(self):
        """
        hook视频挂链
        """
        self.frida_object.exports.hooker_video_goods(
            self.device,
            self.get_response
        )

    def hooker_topic_activity(self, tab=1):
        """
        hook视频活动
        """
        self.frida_object.exports.hooker_topic_activity(
            self.device,
            tab,
            self.get_response
        )

    def hooker_topic_topic(self):
        """
        hook视频话题
        """
        self.frida_object.exports.hooker_topic_topic(
            self.device,
            self.get_response
        )

    def hooker_getcookie(self):
        """
        hook微信cookie
        """
        self.frida_object.exports.hooker_getcookie(
            "cookie",
            "v2_060000231003b20faec8c5e08a18c4dcc60cec31b077b2e0eab771d78025b3800ae7b330f30e@finder"
        )

    def hooker_product_third(self):
        """
        hook带货中心商品详情
        """
        self.frida_object.exports.hooker_product_third(
            self.device,
            "wx2cea70df4257bba8",
            self.vx_cookie,
            self.get_response
        )

    def hooker_product_takecenter(self):
        """
        hook带货中心商品列表
        """
        self.frida_object.exports.hooker_product_takecenter(
            self.device,
            "wx2cea70df4257bba8",
            self.vx_cookie,
            self.get_response
        )

    def hooker_product_store(self):
        """
        hook微信小商店信息
        """
        self.frida_object.exports.hooker_product_store(
            self.device,
            "wx34345ae5855f892d",
            self.get_response
        )

    def hooker_product_info(self):
        """
        hook微信小商店商品详情
        """
        self.frida_object.exports.hooker_product_info(
            self.device,
            "wx34345ae5855f892d",
            self.get_response
        )

    def hooker_product_list(self):
        """
        hook微信小商店商品列表
        """
        self.frida_object.exports.hooker_product_list(
            self.device,
            "wx34345ae5855f892d",
            self.get_response
        )

    def hooker_live_tab(self):
        """
        hook直播分类
        """
        self.frida_object.exports.hooker_live_tab(self.device)

    def hooker_live_square(self):
        """
        hook直播广场
        """
        for i in self.get_response.get("data").get("cates"):
            if i.get("cateid") > 10:
                continue
            self.check_frida()
            self.frida_object.exports.hooker_live_square(
                self.device,
                {
                    "VHZ": i.get("cateid"),
                    "VIa": i.get("catename"),
                    "VIb": False,
                    "VIc": False,
                    "VId": False,
                    "VIe": False,
                    "VIf": [],
                    "VIg": 0,
                    "data": "",
                    "includeUnKnownField": False,
                    "object_id": 0
                }
            )
            self.wait()

    def hooker_live_goods(self):
        """
        hook直播带货
        """
        self.frida_object.exports.hooker_live_goods(
            self.device,
            self.username,
            self.get_response
        )

    def hooker_live_contribution(self):
        """
        hook直播间热度贡献榜
        """
        self.frida_object.exports.hooker_live_contribution(
            self.device,
            self.username,
            self.get_response
        )

    def hooker_live_barrage(self):
        """
        hook直播间弹幕
        """
        self.frida_object.exports.hooker_live_barrage(
            self.device,
            self.username,
            self.get_response
        )

    def hooker_live_info(self):
        """
        hook直播间信息
        """
        self.frida_object.exports.hooker_live_info(
            self.device,
            self.username,
            self.get_response
        )

    def hooker_detail_goods(self):
        """
        hook主页商品
        """
        self.frida_object.exports.hooker_detail_goods(
            self.device,
            self.get_response
        )

    def hooker_detail_video(self):
        """
        hook主页视频
        """
        self.frida_object.exports.hooker_detail_video(
            self.device,
            self.get_response
        )

    def hooker_video_comment(self):
        """
        hook视频评论
        """
        self.frida_object.exports.hooker_video_comment(
            self.device,
            False,
            self.get_response
        )

    def adapter_business(self):
        """
        hook业务分发
        """
        self.check_frida()
        self.get_params()
        if self.device == "comment":
            self.Adapter["hooker_video_comment"]()
            self.wait()
        elif self.device == "detail":
            self.Adapter["hooker_detail_video"]()
            self.wait()
            self.check_frida()
            self.Adapter["hooker_detail_goods"]()
            self.wait()
        elif self.device == "hourlist":
            if not (self.vx_cookie and os.path.exists(self.cookie_file)):
                self.get_cookie()
                self.wait_cookie()
            content = self.make_hourlist_response(self.get_response)
            self.post_response = content
            self.Handle[self.device](config.post_url.get(self.device).format(self.uuid, self.addr))
        elif self.device == "livebarrage":
            self.Adapter["hooker_live_barrage"]()
            self.wait()
        elif self.device == "liveinfo":
            self.Adapter["hooker_live_info"]()
            self.wait()
        elif self.device == "livecontribution":
            self.Adapter["hooker_live_contribution"]()
            self.wait()
        elif self.device == "livegoods":
            self.Adapter["hooker_live_goods"]()
            self.wait()
        elif self.device == "livesquare":
            self.Adapter["hooker_live_tab"]()
            self.wait()
            self.Adapter["hooker_live_square"]()
        elif self.device == "product":
            if self.get_response.get("data").get("method") == "GetShopCenter":
                self.Adapter["hooker_product_store"]()
            elif self.get_response.get("data").get("method") == "BatchGetProductByBizUin":
                self.Adapter["hooker_product_list"]()
            elif self.get_response.get("data").get("method") == "GetProduct":
                self.Adapter["hooker_product_info"]()
            elif self.get_response.get("data").get("method") == "EcGetItemList":
                if self.vx_cookie:
                    self.Adapter["hooker_product_takecenter"]()
                else:
                    self.get_cookie()
                    self.wait_cookie()
                    self.check_frida()
                    self.Adapter["hooker_product_takecenter"]()
            elif self.get_response.get("data").get("method") == "EcGetItemDetail":
                if self.vx_cookie:
                    self.Adapter["hooker_product_third"]()
                else:
                    self.get_cookie()
                    self.wait_cookie()
                    self.check_frida()
                    self.Adapter["hooker_product_third"]()
            else:
                self.logger.error("product business undefined method %s ." % self.get_response.get("data").get("method"))
            self.wait()
        elif self.device == "topic":
            if int(self.get_response["data"].get("type")) == 1:
                self.Adapter["hooker_topic_topic"]()
            elif int(self.get_response["data"].get("type")) == 2:
                self.Adapter["hooker_topic_activity"](1)
                self.wait()
                self.check_frida()
                self.Adapter["hooker_topic_activity"](2)
            else:
                self.logger.error("topic business undefined type %s ." % self.get_response["data"].get("type"))
            self.wait()
        elif self.device == "videogoods":
            self.Adapter["hooker_video_goods"]()
            self.wait()
        elif self.device == "videourl":
            self.Adapter["hooker_video_url"]()
            self.wait()
        else:
            self.logger.error("can't find this device: %s" % self.device)
        time.sleep(
            random.randint(
                self.sleep_time.get(self.device).get("begin"),
                self.sleep_time.get(self.device).get("end")
            )
        )


class HandleBusiness(AdapterBusiness):
    """
    对send回来的数进行适配，分发到对应的业务链上处理
    """
    Handle = dict()

    def __init__(self, filename, device, url, full_path=""):
        AdapterBusiness.__init__(self, filename, device, url, full_path)
        for i in dir(self):
            self.Handle[i] = getattr(self, i)

    def cookie(self, post_url):
        """
        微信cookie
        :param post_url : 数据回调地址
        """
        self.flag = True
        self.wait_count = 0
        self.remove_monitor = False
        self.get_cookie(self.post_response.get("result").get("VWA"))

    def comment(self, post_url):
        """
        视频评论
        :param post_url : 数据回调地址
        """
        status = requests.post(post_url, json.dumps(self.post_response).encode("utf-8").decode("latin1"))
        self.flag = True
        self.wait_count = 0
        self.remove_monitor = False
        self.logger.info(str(self.post_response.get("device")) + str(status))

    def detail(self, post_url):
        """
        主页信息
        :param post_url : 数据回调地址
        """
        status = requests.post(post_url, json.dumps(self.post_response).encode("utf-8").decode("latin1"))
        self.flag = True
        self.wait_count = 0
        self.remove_monitor = False
        self.logger.info(str(self.post_response.get("device")) + str(status))

    def hourlist(self, post_url):
        """
        小时榜
        :param post_url : 数据回调地址
        """
        for c in self.post_response:
            c["username"] = self.get_response["data"].get("username")
            c["curtime"] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(int(time.time())))
            status = requests.post(post_url, json.dumps(c, ensure_ascii=False).encode("utf-8").decode("latin1"))
            self.logger.info(str(c.get("device")) + str(status))

    def livebarrage(self, post_url):
        """
        直播间弹幕
        :param post_url : 数据回调地址
        """
        status = requests.post(post_url, json.dumps(self.post_response).encode("utf-8").decode("latin1"))
        self.flag = True
        self.wait_count = 0
        self.remove_monitor = False
        self.logger.info(str(self.post_response.get("device")) + str(status))

    def liveinfo(self, post_url):
        """
        直播间信息
        :param post_url : 数据回调地址
        """
        status = requests.post(post_url, json.dumps(self.post_response).encode("utf-8").decode("latin1"))
        if self.device == self.post_response.get("device"):
            self.flag = True
        self.wait_count = 0
        self.remove_monitor = False
        self.logger.info(str(self.post_response.get("device")) + str(status))

    def livecontribution(self, post_url):
        """
        直播间热度贡献榜
        :param post_url : 数据回调地址
        """
        status = requests.post(post_url, json.dumps(self.post_response).encode("utf-8").decode("latin1"))
        self.flag = True
        self.wait_count = 0
        self.remove_monitor = False
        self.logger.info(str(self.post_response.get("device")) + str(status))

    def livegoods(self, post_url):
        """
        直播间带货
        :param post_url : 数据回调地址
        """
        status = requests.post(post_url, json.dumps(self.post_response).encode("utf-8").decode("latin1"))
        self.flag = True
        self.wait_count = 0
        self.remove_monitor = False
        self.logger.info(str(self.post_response.get("device")) + str(status))

    def livesquare(self, post_url):
        """
        直播广场
        :param post_url : 数据回调地址
        """
        status = requests.post(post_url, json.dumps(self.post_response).encode("utf-8").decode("latin1"))
        if int(self.post_response.get("type")) == 2:
            if int(self.post_response.get("hasnext")) == 0:
                self.flag = True
            else:
                self.wait_count = 0
        else:
            self.flag = True
            self.wait_count = 0
        self.logger.info(str(self.post_response.get("device")) + str(status))

    def product(self, post_url):
        """
        微信小商店和带货中心
        :param post_url : 数据回调地址
        """
        if self.post_response.get("method") == "EcGetItemList" or self.post_response.get("method") == "EcGetItemDetail":
            if self.post_response.get("flag") in ["-330", "-333", "-334"] and os.path.exists(self.cookie_file):
                os.remove(self.cookie_file)
                self.vx_cookie = None
                self.logger.info("the cookie has expired. obtain it again.")
                self.flag = True
            else:
                status = requests.post(post_url, json.dumps(self.post_response).encode("utf-8").decode("latin1"))
                self.flag = True
                self.logger.info(str(self.post_response.get("device")) + str(status))
        else:
            if self.post_response.get("method") == "BatchGetProductByBizUin" and self.post_response.get("next_key") == "" and int(
                    self.post_response.get("page_num")) > 0:
                self.flag = True
            elif self.post_response.get("method") == "cookie":
                self.get_cookie(self.post_response.get("result").get("VWA"))
                self.flag = True
            else:
                status = requests.post(post_url, json.dumps(self.post_response).encode("utf-8").decode("latin1"))
                if self.post_response.get("method") == "GetProduct" or self.post_response.get("method") == "GetShopCenter":
                    self.flag = True
                self.logger.info(str(self.post_response.get("device")) + str(status))
        self.wait_count = 0
        self.remove_monitor = False

    def topic(self, post_url):
        """
        话题和活动
        :param post_url : 数据回调地址
        """
        status = requests.post(post_url, json.dumps(self.post_response).encode("utf-8").decode("latin1"))
        if int(self.post_response.get("continueFlag")) == 0:
            self.flag = True
        else:
            self.wait_count = 0
        self.remove_monitor = False
        self.logger.info(str(self.post_response.get("device")) + str(status))

    def videogoods(self, post_url):
        """
        视频挂链
        :param post_url : 数据回调地址
        """
        status = requests.post(post_url, json.dumps(self.post_response).encode("utf-8").decode("latin1"))
        self.flag = True
        self.wait_count = 0
        self.remove_monitor = False
        self.logger.info(str(self.post_response.get("device")) + str(status))

    def videourl(self, post_url):
        """
        视频播放地址
        :param post_url : 数据回调地址
        """
        status = requests.post(post_url, json.dumps(self.post_response).encode("utf-8").decode("latin1"))
        self.flag = True
        self.wait_count = 0
        self.remove_monitor = False
        self.logger.info(str(self.post_response.get("device")) + str(status))

    def handle_business(self):
        """
        send数据适配主逻辑
        """
        try:
            post_url = config.post_url.get(self.post_response.get("device")).format(self.uuid, self.addr)
        except Exception as e:
            self.logger.info("currently, it is an internal service")
            post_url = None
        self.Handle[self.post_response.get("device")](post_url)

以上就是我自己项目的hook核心逻辑和数据处理核心逻辑，大体上来讲就是：从队列拿到hook参数，匹配hook点，对hook到的数据进行处理和回调。

• AdapterBusiness：对hook业务进行适配，分发到对应的业务链上进行hook。“adapter_business”该方法是hook的核心，可以看下对应的逻辑：首先self.check_frida()检测frida，如果没有会创建frida对象；然后看书获取hook参数，这里先检测frida再拿参数是为了避免参数流失过多；最后开始匹配hook点，比如“comment”举例：它会匹配“hooker_video_comment”这个hook点，进入方法内部self.frida_object.exports.hooker_video_comment()实现rpc远程调用（好玄学的），进入到javascript中的hook逻辑，最终会把hook到的数据send出去，而python的流程就会被self.wait()这个方法卡住，等待send回来的数据进行分析

• HandleBusiness：对send回来的数进行适配，分发到对应的业务链上处理。“handle_business”该方法时数据处理的核心，他会根据send回来的“device”字段进行匹配回调业务，比如“comment”继续举例：此时send回来的数据已被self.post_response接收，回调完成后要让self.wait()方法放行进行下一次hook，于是就设置self.flag、self.wait_count、self.remove_monitor，使其放行，这三个的具体作用源码中有讲述

B、base_script：frida的核心创建逻辑、对外部分交互和用到的模块载入

# !/usr/bin/env python
# coding=utf-8
# @Time    : 2022/04/20
# @Author  : XQE
# @Software: PyCharm


"""
整个采集脚本的基础类
完整的流程：
1.hook加载类(js加载数据)
2.hook数据类(js获取数据)
"""

import re
import sys
import time
import frida
import config
import requests
sys.path.append("../common")
sys.path.append("../../common")
from logging_model import Logging
from process_model import Process
from ident_model import Ident
from phone_model import Phone


class BaseScript(Logging, Process, Ident, Phone):
    flag = False
    device = ""
    wait_count = 0
    frida_object = None
    get_response = dict()
    post_response = dict()
    remove_monitor = False

    def __init__(self, filename, device, url, full_path=""):
        """
        初始化对象：
        :param filename : 工作空间文件名
        :param full_path : 完整路径
        """
        self.device = device
        self.filename = filename
        self.timeout = config.timeout
        self.frida_host = config.frida_host
        self.app_name_en = config.app_name_en
        self.app_name_ch = config.app_name_ch
        self.hook_script = config.hook_script
        Logging.__init__(self, filename, device, full_path)
        Process.__init__(self, filename, device + re.search(r"\d+", filename).group(), "../monitor/monitor_conf.ini", full_path)
        Ident.__init__(self, filename, full_path)
        Phone.__init__(self, config.adb_host, self.app_name_en, config.app_ui)
        self.addr = self.get_host_ip()
        self.uuid = self.get_workspace_uuid()
        self.get_params_url = url

    def check_frida(self):
        """
        检测frida
        """
        if self.frida_object is None:
            self.frida_object = self.session()

    def session(self):
        """
        frida远程植入微信进程
        :return: 植入载体
        """
        session = None
        while session is None:
            device = None
            try:
                manager = frida.get_device_manager()
                device = manager.add_remote_device(self.frida_host)
            except Exception as e:
                self.logger.error("frida connect fail: " + str(e), exc_info=False)
            if device is not None:
                try:
                    session = device.attach(self.app_name_en)
                    self.logger.info("frida attach appname %s" % self.app_name_en)
                except Exception as e:
                    self.logger.error("frida attach %s fail: " % self.app_name_en + str(e), exc_info=False)
                    try:
                        session = device.attach(self.app_name_ch)
                        self.logger.info("frida attach appname %s" % self.app_name_ch)
                    except Exception as e:
                        self.logger.error("frida attach %s fail: " % self.app_name_ch + str(e), exc_info=False)
                        time.sleep(5)
        try:
            with open(self.hook_script, encoding="utf-8") as f:
                script = session.create_script(f.read(), runtime="v8")
                script.on("message", self.my_message_handler)
                script.load()
                self.logger.info("hook script success.")
                return script
        except Exception as e:
            self.logger.error("frida create script fail: " + str(e), exc_info=False)

    def wait(self):
        """
        限时等待js响应
        """
        self.wait_count = 0
        self.flag = False
        while True:
            time.sleep(0.1)
            self.wait_count += 1
            if self.flag or self.wait_count > self.timeout:
                if self.wait_count > self.timeout:
                    self.logger.info("hook time out ...")
                    # 当存在风控风险时重启设备
                    if self.remove_monitor:
                        self.logger.info("reboot phone ...")
                        self.reboot()
                    if self.frida_object:
                        self.frida_object.unload()
                    break
                self.flag = False
                break

    def get_params(self):
        """
        获取队列消息
        """
        while True:
            try:
                self.get_response = requests.get(self.get_params_url.format(self.uuid, self.addr))
                self.get_response.encoding = "utf-8"
                self.get_response = self.get_response.json()
                self.logger.info(self.get_response)
                if self.get_response.get("code") == 0:
                    self.logger.info("the current business: %s" % self.device)
                    break
                time.sleep(1)
            except Exception as e:
                self.logger.error("params queue closed: " + str(e), exc_info=False)

• frida的创建：”session“方法，如果没有创建成功，会一直卡在这里，不会消耗队列的数据，这里创建的时远程连接
• 对外交互：“get_params”方法，获取队列中的hook参数，v1.0是设置权限的，v2.0是进程池的，代码有点差距
• init：初始化方法，加载的所有相关的模块都在这实现了，少部分会在business.py中加载
• wait：等待hook回传数据，比较灵活，可以看为一个进程锁

五、使用步骤

以下的前提是：搭好了架构和环境

1.安装python依赖

根据requirements.txt文件中的版本安装好第三方库，指令在该文件末尾，安装时候记得删除最后两行的指令（建议使用外网安装，不然就自己手动网上去找对应的frida==15.1.10的第三方库）

2.配置项目文件build.ini

# 项目全局配置
[project]
# 项目目录
path=D:\\工作目录\\cpFrida\\v1.0

# python环境
[python_v]
# python版本
python=3.8

# 监控配置
[monitor]
# 重启时间差
reboot=180

# 工作空间配置
[comment1]
# py等待js最大send时长
timeout=150
# frida IP端口
frida_host=114.114.114.114:10406
# adb IP端口
adb_host=114.114.114.114:10706
# app英文包名
app_name_en=com.tencent.mm
# app中文包名
app_name_ch=微信
# app首页ui
app_ui=com.tencent.mm/com.tencent.mm.ui.LauncherUI
# 工作空间名称
workspace=comment1
# hook脚本
hook_script=vx_hooker_8015.js
# 队列池
get_url={"comment": "http://114.114.114.114:8182/comment/8015/task?uuid={}&host={}", "detail": "http://114.114.114.114:8181/detail/8015/task?uuid={}&host={}", "livebarrage": "http://114.114.114.114:8187/livedanmu/8015/task?uuid={}&ip={}", "liveinfo": "http://114.114.114.114:8187/live/8015/task?uuid={}&host={}", "livecontribution": "http://114.114.114.114:8187/liveonlineuser/8015/task?uuid={}&host={}", "livegoods": "http://114.114.114.114:8187/liveproduct/8015/task?uuid={}&host={}", "livesquare": "http://114.114.114.114:8186/livesquare/8015/task?uuid={}&host={}", "product": "http://114.114.114.114:8180/product/8015/task?uuid={}&ip={}", "topic": "http://114.114.114.114:8181/topic/8015/task?uuid={}&host={}", "videogoods": "http://114.114.114.114:8185/videoproduct/8015/task?uuid={}&host={}", "hourlist": "http://114.114.114.114:8186/liverank/8015/task?uuid={}&host={}", "videourl": "http://114.114.114.114:8184/videourl/7012/task?uuid={}&host={}"}
# 回调池
post_url={"comment": "http://114.114.114.114:8182/comment/8015/callback?uuid={}&host={}", "detail": "http://114.114.114.114:8181/detail/8015/callback?uuid={}&host={}", "livebarrage": "http://114.114.114.114:8187/livedanmu/8015/callback?uuid={}&ip={}", "liveinfo": "http://114.114.114.114:8187/live/8015/callback?uuid={}&host={}", "livecontribution": "http://114.114.114.114:8187/live/8015/callback?uuid={}&host={}", "livegoods": "http://114.114.114.114:8187/live/8015/callback?uuid={}&host={}", "livesquare": "http://114.114.114.114:8186/livesquare/8015/callback?uuid={}&host={}", "product": "http://114.114.114.114:8180/product/8015/callback?uuid={}&ip={}", "topic": "http://114.114.114.114:8181/topic/8015/callback?uuid={}&host={}", "videogoods": "http://114.114.114.114:8185/videoproduct/8015/callback?uuid={}&host={}", "hourlist": "http://114.114.114.114:8186/liverank/8015/callback?uuid={}&host={}", "videourl": "http://114.114.114.114:8184/videourl/7012/callback?uuid={}&host={}"}
# 当前设备username
username=
# 消息发送地址
inform_url=https://open.feishu.cn/open-apis/bot/v2/hook/1234
# 工作空间标识
uuid=19f97342-fc64-40e3-b9d2-e5a48e0b8549

注意：首先是项目路径“project”，一定配置正确；其次如果你有多个手机的话直接仿造device1的配置项在build.ini创建一个新的配置项，以此类推；然后你想要hook那个app自己补上对应的ui名称和包名，当然有些项是专属的，比如username可以不用、inform_url自己的通知api等等，具体看配置文件的说明；最后一定要把build.ini放在deploy文件夹下，写死的

3.deploy.py的用法

上图中快速生成工作空间代码的使用场景：

• 第一行：linux中一键部署会用到，指令：
  python deploy.py release_workspace
  python deploy.py receive_workspace ， 如果指的收纳的时候要覆盖当前的build.ini文件的配置项，在指令后面加个参数True
• 第二行：本地调试，生成工作空间
• 第三行：本地调试，收纳工作空间
• 第四行：本地调试，生成指定的工作空间
• 第五行：本地调试，收纳指定的工作空间，如果指的收纳的时候要覆盖当前的build.ini文件的配置项，第一个参数True

4.项目启动文件说明

# !/usr/bin/env python
# coding=utf-8
# @Time    : 2022/02/23
# @Author  : XQE
# @Software: PyCharm


"""
整个采集项目的启动入口
兼容windows和linux系统
"""


import os
import configparser


cmd_str = r"""#!/bin/bash

source /etc/profile
echo "============================== Linux deploy start ! =============================="
crontab -l | grep -v '{project_path}/workspaces/monitor' | crontab -
cd {project_path}/startproject
python3.8 /wechatserver/wxhook/startproject/kill_process.py
cd {project_path}/deploy
python3.8 {project_path}/deploy/deploy.py receive_workspace
python3.8 {project_path}/deploy/deploy.py release_workspace
sleep 3
nohup python3.8 {project_path}/startproject/reboot_phone.py >/dev/null 2>&1 &
sleep 120
if [ -d "{project_path}/workspaces/Process" ]; then
    rm -rf {project_path}/workspaces/Process
fi

echo "============================== Linux deploy end ! =============================="
echo "****************************** Start youwant project . ******************************"

cd {project_path}/workspaces/device1
bash {project_path}/workspaces/device1/device1.sh
echo "comment1 start OK ! "

sleep 60
echo "*/5 * * * * . /etc/profile;cd {project_path}/workspaces/monitor && python3.8 {project_path}/workspaces/monitor/monitor.py &" >> /var/spool/cron/root
echo "****************************** Start youwant project OK ! ******************************"
echo "============================== All steps completed ! =============================="
"""


def read_conf(config_path):
    """
    读取监控配置文件
    :param config_path:配置文件路径
    :return:配置文件
    """
    config = None
    try:
        config = configparser.ConfigParser()
        config.read(config_path, encoding="utf-8")
    except Exception as e:
        print("Project is not run .")
    return config


def create_shell(start_sh, project_path):
    """
    创建项目启动文件
    :param start_sh: 项目启动sh文件
    :param project_path: 项目目录
    :return:
    """
    with open(start_sh, mode="w", encoding="utf-8") as f:
        f.write(cmd_str.format(project_path=project_path))


if __name__ == '__main__':
    project_path = read_conf("../deploy/build.ini")["project"]["path"]
    start_sh = os.path.join(os.path.join(project_path, "startproject"), "start_project.sh")
    create_shell(start_sh, project_path)

注意：“cmd_str ”这里面的shell脚本才是关键，其他配置我都写好了，只是当你在build.ini添加了新设备的配置项之后，这边也要加上对应的项目进程启动入口，下面有原本有的device1，假如我加了device2配置项：

• 原有的：

cd {project_path}/workspaces/device1
bash {project_path}/workspaces/device1/device1.sh
echo "device1 start OK !"

• 添加device2:

cd {project_path}/workspaces/device1
bash {project_path}/workspaces/device1/device1.sh
echo "device1 start OK !"

cd {project_path}/workspaces/device2
bash {project_path}/workspaces/device1/device2.sh
echo "device2 start OK !"

这样就每个进程池或者进程都十分明显了

5.本地调试

在本地调试的话，就不需要用到一键部署了，startproject目录下的文件对你来说就是鸡肋，就很简单了：找到deploy文件夹下的deploy.py，参考3、deploy.py的用法，它会根据你的build.ini自动帮你解压出所有的工作空间，类似上面的device1，直接在本地运行即可

6.远程部署（Jenkins）

远程部署需要用到Jenkins，这边不做太多的赘述了主页有搭建步骤。我们利用Jenkins拉去代码到远程Linux服务器，在拉完代码之后执行start_project.py文件，它会在startproject目录下生成一个start_project.sh文件，利用bash运行它即可，用过Jenkins的应该指定怎么配置了把（手动滑稽）

7.路径的问题

会遇到一些路径的问题，一定要记得该项目路径：

• reboot_phone.py
• start_project.py
• build.ini
  尤其是前面两个，不行的话就直接该代码，我用的是路径拼接的，可以直接传完整路径，都是“project_path”这个属性，自行修改

8.源码

github地址
如果觉得有用，拉完就点个赞

总结

以上叭叭叭说了这么多，看到最后的都是牛人，先脸皮厚要个三连吧，不管你看没看懂，创作真的累，分享思想和技术更累，要想着怎么说才能通俗易懂。。。。。。

总结一下吧：文章中提到的技术，在我博客首页都有相关的博客学习，还是那句话：看到就是赚到。架构搭建不是那么麻烦，很多东西都已经封装好了，自己扩展扩展也许就能满足你自己的业务了（哈哈哈哈）动手试试吧。这个代码的思路是我沉淀几个月的时间了，但是我相信还有漏洞或者不完美，欢迎使用后回馈哈，也许你能优化到更加简便，到时候欢迎在评论区留下自己的见解哈。最后关注博主，带你学习一些正常的、奇奇怪怪的技术哈~~~

心情复杂。。。。。。

补充：
v1.0做了些优化，速度会快一些，然后加了些功能
经过这写天的测试，发现v2.0速度要快，但是不是很稳定，app和手机老是重启，可能是多进程同时hook不同点时，app中的一些资源被占用导致的吧，所有这边后续可能只会更新v1.0了