破解CSU校园跑步

本来是去年6月份的文，拖到现在

preface

技术栈：小程序反编译，JS逆向，蓝牙伪造，抓包，移动端

正常来说，跑步定位有两种方式，一种是GPS定位，一种是基站定位，大部分软件都会采用GPS定位，目前最精确的也是GPS定位，GPS定义可以获取具体的经纬度，当在地图上移动的时候，也能获取到具体的移动路线，而基站定位只能获取大致范围，比如某某公司附近，某某广场旁，无法显示具体移动路线，所以大部分传统跑步定位只需要模拟GPS信号即可

如上，传统校园跑只需模拟GPS信号，内卷的话可以再检测陀螺仪运动，但题主这次碰到的情况是只检测了GPS和蓝牙

背景

由于题主吹牛波一，觉得绕过跑步这种太过简单，早早夸下海口，结果在用fakelocation的时候怎么也绕不过去。

对方用的是跑步小程序，绑定手机号连接到学校后台，然后开始跑步，跑步前要开启小程序蓝牙权限（伏笔）。

开始Bypass

题主用fakelocation模拟步数后，在各个地图app下都可以看到明显的跑步轨迹，围绕校园操场做不是很规则的椭圆运动，但小程序的开始跑步就是点不动（没反应），对方跑到操场去后发现即可点动，怀疑疑似蓝牙相关，聪明的我开始搜索相关关键字：找到下文

中南大学－阳光课外锻炼系统－竞价公告-机电设备采购平台

一般这种软件都是通过招标进入的学校，找招标文书看就行了，既然确认了小程序与蓝牙定位相关。联想到我大四的时候学校有人破解了共享单车，原理也是通过小程序的蓝牙包伪造，联系到同学。

同学跟我说这个是蓝牙BLE相关，让我去学一下概念和小程序API

蓝牙低功耗 (Bluetooth Low Energy, BLE) | 微信开放文档

如上介绍，蓝牙BLE简单理解也是由一个服务端Server 中心设备和多个客户端client 外围设备组成。

在大部分情况下，一般由一个蓝牙桩在某个地点充当服务端，用户的手机等移动设备充当客户端，像共享单车，本文的跑步定位都是这种。当然服务端和客户端也可以反过来。

现在知道了蓝牙定位的大概原理，我们就需要进行绕过，作为多年安全搬砖工程师，第一反应肯定是伪造绕过，于是我们就需要知道如何伪造蓝牙信号，因为此次跑步端采用小程序实现，小程序本质是本地运行Javascript的，我们可以通过一些反编译手段，获取小程序的源代码，通过对源代码的审计来进行伪造。

小程序在安卓机上的存储地址是

/data/data/com.tencent.mm/MicroMsg/{一串16进制字符}/appbrand/pkg/

由于我的物理机有太多小程序，小程序的文件夹是随机字符串，于是我在安卓模拟器上只运行一次小程序，再通过ADB安卓调试工具将上面的文件夹脱了下来，但即使这样小程序文件夹中也存在多个文件夹，由于不好分辨具体哪个是我的目标小程序我只能全部下载，分别反编译后在判断那个是我的目标。

微信小程序反编译可以用下面这个工具

https://github.com/xuedingmiaojun/wxappUnpacker

使用wxappUnpacker进行反编译，开始进行代码审计

然后就是正常的Js审计，会小程序开发的会熟悉一些，里面的代码就是正常的小程序目录结构。但由于正常小程序打包会进行一些pack操作导致丢失一部分逻辑链和符号信息。类似webpack，所以审计起来会有一点麻烦。但好在此系统主题逻辑代码并没有丢失太多。所以审计起来不太费力。

小程序在使用的时候要点击 蓝牙功能，我们根据微信小程序api找到对应函数

所以全局搜索startBluetoothDevicesDiscovery，定位到函数调用点

根据实际情况，我们无法开始跑步，所以我们的目的是找到开始跑步的函数，即入口点。

根据api，小程序开始扫描蓝牙设备后需要通过onBluetoothDeviceFound 监听函数进行事件处理，此函数的返回值包含了扫描到的蓝牙设备。继续搜索

onBluetoothDeviceFound: function() {
        var a = this;
        wx.getBluetoothDevices({
            success: function(e) {
                for (var n = 0; n < e.devices.length; n++) {
                    var o = 0;
                    if ("xBeacon" == e.devices[n].localName || "xBeacon" == e.devices[n].name) {
                        if (null != e.devices[n].serviceData && void 0 != e.devices[n].serviceData && e.devices[n].serviceData.hasOwnProperty("00001529-0000-1000-8000-00805F9B34FB")) for (var i = 0; i < a.data.deviceList.length; i++) if (a.data.deviceList[i].deviceAddress == t(e.devices[n].serviceData["00001529-0000-1000-8000-00805F9B34FB"])) {
                            a.venueCardRegister(a.data.deviceList[i].deviceId);
                            var r = new Date();
                            a.setData({
                                lastdata: r,
                                gspstatus: 0,
                                yxvalidCount: a.data.yxvalidCount + 1,
                                quyuoff: !0
                            }), wx.setStorageSync("lastdata", a.data.lastdata), wx.setStorageSync("yxvalidCount", a.data.yxvalidCount), 
                            o = 1, wx.stopBluetoothDevicesDiscovery({
                                success: function(a) {
                                    wx.closeBluetoothAdapter({
                                        success: function(a) {
                                            wx.openBluetoothAdapter({
                                                success: function(a) {
                                                    wx.startBluetoothDevicesDiscovery({
                                                        powerLevel: "high",
                                                        success: function(a) {},
                                                        fail: function(a) {}
                                                    });
                                                }
                                            });
                                        }
                                    });
                                }
                            });
                            break;
                        }
                        if (1 == o) break;
                    }
                }
            },

可以看到，这个函数直接对所有扫描的设备进行遍历，判断扫描的设备名字是否含有 xBeacon

如果有，则判断其serviceData是否属性名00001529-0000-1000-8000-00805F9B34FB

现在我们知道了程序的逻辑，但现在有个小问题，我们是通过反向审计找到的功能点，程序内不止一个判断蓝牙设备的函数，我们不能判定这个函数就是开始跑步所判断的函数，我们还需要找到对应的函数入口。

好在进行搜索，程序内所有的蓝牙判断函数都是一样的，我们可以放心的按照上面的模式进行伪造。但如果要找到程序入口，我们可以从前端下手。

小程序里面，需要点击长按开始 开始跑步，全局搜索可以搜到对应小程序前端和点击事件

根据正常的审计经验，基本可以判断这个函数就是真正的入口判断函数，可以看到，如果没有找到蓝牙设备，会弹出右下获取线路，请前往指定区域 这也符合小程序的逻辑。

Solve

现在我们需要Bypass进行绕过，我当时想到了两个思路

1. 将小程序的判断逻辑删除进行重打包
2. 使用frida动态hook绕过判断
3. 模拟一个符合程序规范的蓝牙BLE设备

第一个思路，微信会对小程序开发者进行签名，重打包绕不过签名校验，只能使用自己的签名重新打包，但是反编译再编译并不是无损的，会有一堆Bug，过程太繁琐，放弃。

第二个思路，当时Frida Hook小程序资料太少，未找到，放弃

于是使用第三个思路，我一开始想用计算机Python来模拟BLE设备，但只能更改电脑的蓝牙名称，无法发送蓝牙广播，更别谈模拟BLE信号。

然后我准备使用魔法打败魔法，自己开发一个测试小程序发送蓝牙BLE，但是用了所有api，只能使得onBluetoothDeviceFound函数获取到advertisData。无法获取到serviceData。

于是请教了下清华的iot大哥xuanxuan

发现一个神器NRF CONNECT，这个软件可以直接模拟蓝牙BLE，甚至可以直接从周围环境copy蓝牙信号，因为我一直在家里闭门造车，如果可以去到学校操场的话，可以直接用这个软件复制模拟操场的蓝牙插桩。

😠要是早知道这个东西 我还那么努力审什么。

result

拿一个手机开启NRF CONNECT，使用另一个手机点击小程序开始跑步，成功绕过。

放一个结果视频吧
https://v.douyin.com/yFByBFh/

JavaAgent

Javassist基础

简介

可以理解为一个加强版的反射库

不仅可以反射获取各种类 方法 参数，还可以动态修改

原理是通过修改java字节码来实现的

API

Javassist为我们提供了类似于Java反射机制的API，如：CtClass，CtConstructor、CtMethod、CtField与Java反射的Class、Constructor、Method、Field非常的类似。

Untitled

Javassist使用了内置的标识符来表示一些特定的含义，如：$_表示返回值。我们可以在动态插入类代码的时候使用这些特殊的标识符来表示对应的对象。

Untitled

准备动手

同样 maven项目 quickstart

<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
</dependency>
<dependency>
      <groupId>org.javassist</groupId>
      <artifactId>javassist</artifactId>
      <version>3.26.0-GA</version>
</dependency>
<dependency>
      <groupId>commons-lang</groupId>
      <artifactId>commons-lang</artifactId>
      <version>2.6</version>
</dependency>

我们来实现一个User类,debug方法是为了测试方便，假设真实情况不存在debug方法

package org.example;

import java.util.Random;
import org.apache.commons.lang.RandomStringUtils;
public class User {

    private String secret;
    public String flag;

    public User(){
        this.secret = RandomStringUtils.randomAlphanumeric(32);
        this.flag = "flag{0xevoA}";
    }
    public String getFlag(String input){
        if(input.equals(this.secret)){

            System.out.println(this.flag);
            return this.flag;
        }
        else {
            System.out.println("nnnn");
            return "nnnn";
        }
    }
    public void debug(){
        System.out.println(this.secret);
        System.out.println(this.flag);
    }
}

假设这个类被加载到了内存中，类文件被删除，并且我们不知道flag的值，通过反射直接获取flag，如何通过javassist 修改获取flag呢？

1. 直接将字节码写入成.class文件然后反编译

@Test
    public void jassist1() throws NotFoundException, IOException, CannotCompileException {
        ClassPool classPool = ClassPool.getDefault();
        CtClass user = classPool.getCtClass("User");
        user.defrost();
        byte[] bytecodes = user.toBytecode();
        FileOutputStream fileOutputStream = new FileOutputStream(new File(System.getProperty("user.dir") + "/src/test/User.class"));
        fileOutputStream.write(bytecodes);
        fileOutputStream.close();
    }

不用多说了8,看看代码就行了，动手敲一下

1. 直接输出flag变量

@Test
public void jassist2() throws NotFoundException, IOException, CannotCompileException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
    ClassPool classPool = ClassPool.getDefault();
    CtClass cUser = classPool.getCtClass("User");
    cUser.defrost();
    // create method
    CtMethod ctMethod = CtMethod.make("public void cheatEngine(){System.out.println(this.flag);}", cUser);
    cUser.addMethod(ctMethod);
    Object user = cUser.toClass().newInstance();
    Method cheatEngine = user.getClass().getMethod("cheatEngine");
    cheatEngine.invoke(user);

}

新建了一个cheatEngine方法，直接输出this.flag

看代码就行，不说废话

1. 如果flag是 private static

private String secret;
    private static String flag = "flag{0xeevoA}";

    public User(){
        this.secret = RandomStringUtils.randomAlphanumeric(32);
    }

static，private在这里没什么影响sout(this.flag)照样输出，当然，如果是static的话sout(flag)也可以

1. 修改getFlag方法，在前面加入一行代码修改input

@Test
    public void jassist3() throws NotFoundException, IOException, CannotCompileException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        {
            ClassPool classPool = ClassPool.getDefault();
            CtClass cUser = classPool.getCtClass("User");
            cUser.defrost();

            CtMethod getFlag = cUser.getDeclaredMethod("getFlag");
            System.out.println(getFlag);
            getFlag.insertBefore("$0.secret=\"123456\";");
            System.out.println();
            Object o = cUser.toClass().newInstance();
            Method getFlag1 = o.getClass().getMethod("getFlag", String.class);
            getFlag1.invoke(o,"123456");
        }

$0 就是 this

具体看上面那个表

参考https://y4er.com/post/javassist-learn/

javaAgent

introduce

javaAgent, 可以理解为java自带的hook模式，有点类似php的so拓展，以及动态连接的LD_PROLOAD

Java Agent 支持两种方式进行加载：

1. 实现 premain 方法，在启动时进行加载 （该特性在 jdk 1.5 之后才有）
2. 实现 agentmain 方法，在启动后进行加载 （该特性在 jdk 1.6 之后才有）

我们可以使用JavaAgent实现一些Hook操作

为了生成jar包方便，下面用vscode

public class User {

    private String secret;
    private static String flag = "flag{0xeevoA}";

    public User(){
        this.secret = "secret";
    }
    public String getFlag(String input){
        if(input.equals(this.secret)){

            System.out.println(this.flag);
            return this.flag;
        }
        else {
            System.out.println("nnnn");
            return "nnnn";
        }
    }
    public void debug(){
        System.out.println(this.secret);
        System.out.println(this.flag);
    }

    public static void main(String[] args) {
        User user = new User();
        if(args[0].equals("1")){
            user.debug();
        }
        if(args[0].equals("2")){
            user.getFlag(args[1]);
        }
    }
}

javac User.java 生成User.class

premain

public static void premain(String agentArgs, Instrumentation inst)

premain有两个参数，第一个agentArgs没什么用，主要关注第二个，Instrumentation

是与JVM交互的类，可以动态修改JVM加载的类字节码，结合javassist，我们可以hook所有JVM加载过的类并且为所欲为

声明

public interface Instrumentation {

    // 增加一个 Class 文件的转换器，转换器用于改变 Class 二进制流的数据，参数 canRetransform 设置是否允许重新转换。在类加载之前，重新定义 Class 文件，ClassDefinition 表示对一个类新的定义，如果在类加载之后，需要使用 retransformClasses 方法重新定义。addTransformer方法配置之后，后续的类加载都会被Transformer拦截。对于已经加载过的类，可以执行retransformClasses来重新触发这个Transformer的拦截。类加载的字节码被修改后，除非再次被retransform，否则不会恢复。
    void addTransformer(ClassFileTransformer transformer);

    // 删除一个类转换器
    boolean removeTransformer(ClassFileTransformer transformer);

    // 在类加载之后，重新定义 Class。这个很重要，该方法是1.6 之后加入的，事实上，该方法是 update 了一个类。
    void retransformClasses(Class<?>... classes) throws UnmodifiableClassException;

    // 判断目标类是否能够修改。
    boolean isModifiableClass(Class<?> theClass);

    // 获取目标已经加载的类。
    @SuppressWarnings("rawtypes")
    Class[] getAllLoadedClasses();

    ......
}

Instrumentation主要关注三个方法addTransformer getAllLoadedClasses retransformClasses

1. addTransformer

增加一个transformer(类似php-parse的NodeTraverser)

1. getAllLoadedClasses

获取所有已经load的类

1. retransformClasses

新建一个自定义transformer类 Agent.class

输出所有加载过的类

Agent.class

import java.lang.instrument.Instrumentation;

public class Agent {
    public static void premain(String agentArgs, Instrumentation inst) throws Exception{
        Class[] cs = inst.getAllLoadedClasses(); 
        for(Class c: cs){
            System.out.println(c.getName());
        }
    }
}

新建一个agent.mf

Manifest-Version: 1.0
Premain-Class: Agent
Agent-Class: Agent

运行

javac .\Agent.java 
jar cvfm agent.jar .\Agent.mf .\Agent.class
java -javaagent:agent.jar

即可输出所有load类

然后我们把javassit 和 javaagent连起来，实现

java maven项目（因为要引入javassit）

目录结构

├── pom.xml
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       ├── Agent.java
│   │   │       └── AgentTransformer.java
│   │   └── resources
│   │       └── META-INF
│   │           └── MANIFEST.MF
│   └── test
│       └── java
│           ├── com
│           │   └── AppTest.java

Agent.java

package com;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.Instrumentation;

public class Agent {
    public static void premain(String agentArgs, Instrumentation inst) throws Exception{

        ClassFileTransformer transformer = new AgentTransformer();
        inst.addTransformer(transformer);

    }
}

AgentTransformer.java

package com;
import java.lang.instrument.ClassFileTransformer;
import javassist.*;

import java.lang.reflect.Method;
import java.security.ProtectionDomain;

public class AgentTransformer implements ClassFileTransformer {
    public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,ProtectionDomain protectionDomain, byte[] classfileBuffer){

        className = className.replace("/", ".");
        if(className.equals("User")){
            try {
                ClassPool classPool = ClassPool.getDefault();
                CtClass cUser = classPool.get("User");
                cUser.defrost();
                CtMethod ctMethod = CtMethod.make("public void cheatEngine(){System.out.println(this.flag);}", cUser);
                cUser.addMethod(ctMethod);
                Object user = cUser.toClass().newInstance();
                Method cheatEngine = user.getClass().getMethod("cheatEngine");
                cheatEngine.invoke(user);
            } catch (Exception e) {
                //TODO: handle exception
            }
        }
        return new byte[0];
    }

}

Manifest-Version: 1.0
Premain-Class: com.Agent

打包成jar

选择Project Structure -> Artifacts -> JAR -> From modules with dependencies。

默认的配置就行。

选择Build -> Build Artifacts -> Build。

之后产生out/artifacts/agent_jar/agent.jar：

└── out
    └── artifacts
        └── agent_jar
            └── agent.jar

然后运行User.class

java -javaagent:.\artifacts\javaagent_jar\javaagent.jar User 2 password

成功打印出flag，虽然后续报错，但目的已经达到

参考

http://wjlshare.com/archives/1582
https://xz.aliyun.com/t/9450#toc-12
https://zhishihezi.net/

M3U8解密流程

Dplayer播放器的m3u8解密脚本

https://github.com/DIYgod/DPlayer

前言

暂时只适合未加密的m3u8文件，加密的以后再写

看看能不能用go写一个 感觉会很棒，把下面都集成一下，顺便练练开发（画饼

1. 自行下载m3u8文件（看F12 network找
2. 通过下面脚本获取所有流文件

# pip install aiohttp
# python3.6 以上 支持asyncio
# 在脚本目录下建一个m3u8文件夹
# 默认支持bmp后缀和ts后缀 如是其他后缀下面get_all_url函数第三行bmp或ts改一下
# 最下面将https换成了http 加快下载速度 如果服务端只支持https请删除replace
# 异步比较快 但可能会报错，对已经下载的文件会跳过，报错了退出重新运行，多运行几次到全部下完
import aiohttp
import asyncio
import re
import os
import hashlib

#你下载下来的m3u8文件
filename = "video.m3u8"

#防止文件重名（我就遇到了）
def md5(s):
    return hashlib.md5(s.encode('utf-8')).hexdigest()

def get_all_url():
    file_content = open(filename).read()
    urls = re.findall(r"http.*?\.(bmp|ts)",file_content,re.S)
    return urls

async def fetch(client,url):
    async with client.get(url) as resp:
        return await resp.read()

async def main(url):
    if os.path.exists(f"./m3u8/{md5(url)}.ts"):
        print("url exist: break")
        return
    async with aiohttp.ClientSession() as client:
        body = await fetch(client,url)
        open("./m3u8/"+md5(url)+'.ts',"wb").write(body)
        print(f"download success: {url}")

loop = asyncio.get_event_loop()
tasks = []

for url in get_all_url():
        # !!!!!!自行观察服务器知否支持http，如果不确定就把下面.replace删了，!!!!
    task = loop.create_task(main(url.replace("https","http")))
    tasks.append(task)

#可能报错，报错了就重新运行，直到不下载新的文件
loop.run_until_complete(asyncio.wait(tasks))

1. 合并

网上说ffmpeg可以合并 我命令一直报错（淦

ffmpeg -allowed_extensions ALL -i hls-720p.m3u8 -c copy new.mp4

哦对我这个脚本因为可能文件名会重复md5了一下，需要把m3u8得内容换成md5文件名重新写入才行

脚本如下

同样记得看情况改下面的 bmp

import re
import os
import hashlib

filename = "video.m3u8"
new_filename = "new.m3u8"
def md5(s):
    return hashlib.md5(s.encode('utf-8')).hexdigest()

file_content = open(filename).read()

with open(new_filename,"wb") as txt:
    for i in file_content.split("\n"):
        print(i)
        if re.search("http.*?\.(bmp|ts)",i,re.S):
            i = md5(i)+".ts"
            txt.write(i.encode("utf-8")+b"\n")
        else:
            txt.write(i.encode("utf-8")+b"\n")

然后合并所有文件，我直接用的python合并 3.1G的视频我本地跑了快20分钟，如果有开发大佬可以优化一下

注意下面 url=url.replace("https","http")

import hashlib
import re

filname = "video.m3u8"
def md5(s):
    return hashlib.md5(s.encode('utf-8')).hexdigest()

def get_all_url():
    file_content = open(filename).read()
    urls = re.findall(r"http.*?\.(bmp|ts)",file_content,re.S)
    return urls

urls = get_all_url()
filenames = []
for url in urls:
#!!!!!!!!!!!!!!!!看情况删~之前md5存的时候有没有https!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    url=url.replace("https","http")
    filenames.append(md5(url)+".ts")

big_buffer = b""

i = 1
for filename in filenames:
    print(f"now is {str(i)}| all is {str(num)} ")
    i+=1
    big_buffer += open("m3u8/"+filename,"rb").read()

open("./m3u8_lab/new.ts","wb").write(big_buffer)

bingo

后缀直接改成mp4也可以播放，不知道是容错还是啥（来个misc选手

对了 file命令不好使file啥都是data(- -

如果后缀是ts，windows自带的播放器可以直接打开（我是win11

如果不是，改成ts或者mp4说不定能直接打开，反正file命令是真不行

Preface

抽象语法树(AST)，即Abstract Syntax Tree的缩写。它是源代码语法结构的一种抽象表示。它以树状的形式表现编程语言的语法结构，树上的每个节点都表示源代码中的一种结构。之所以说语法是抽象的，是因为这里的语法并不会表示出真实语法中出现的每个细节。


Python内置一个ast库，其中存在一些内置方法生成，遍历，获取，解析 Python代码并获取ast树，但ast库的官方文档过于简陋，基本上无法当作学习文档。


最简单的Demo

import ast
import astpretty
res = ast.parse("a = 1+1")
astpretty.pprint(res)

Module(
    body=[
        Assign(
            lineno=1,
            col_offset=0,
            end_lineno=1,
            end_col_offset=7,
            targets=[Name(lineno=1, col_offset=0, end_lineno=1, end_col_offset=1, id='a', ctx=Store())],
            value=BinOp(
                lineno=1,
                col_offset=4,
                end_lineno=1,
                end_col_offset=7,
                left=Constant(lineno=1, col_offset=4, end_lineno=1, end_col_offset=5, value=1, kind=None),
                op=Add(),
                right=Constant(lineno=1, col_offset=6, end_lineno=1, end_col_offset=7, value=1, kind=None),
            ),
            type_comment=None,
        ),
    ],
    type_ignores=[],
)

Process finished with exit code 0

astpretty是一个第三方库，用来美化输出ast树


上面的输出结果就是，a = 1 + 1 这句语句对应的ast树的可读形式，
其中Module(body(是所有语句dump出来都会有的，不用管
由于a = 1 + 1是一句赋值语句，所以第一层为 Assign语法
对于每一种结构语法，都会自己对应的语法属性，比如这里的Assign，就存在targets(赋值对象),value(被赋的值),而这些语法属性自己又包含了自己的属性，一层一层嵌套






需要注意的是对于某些表达式，python的ast的遍历顺序是从后到前，从外到内，这个与php的ast遍历顺序不同,有点反人类
比如

request.arg.get(123)
func(a[:5])

第一个获取到的ast对象是 get(123)
第二个获取到的也是函数 func()


当然除了打印ast树，我们也可以直接输出ast树对应的节点

假设有一道CTF题目

#secret.py
def func():
    flag = "xxxxxxxxxxxxxxxxxxxxxxxxx"
    # guess flag

假如我们可以运行一段py脚本,但是不允许读文件,执行系统命令，我们该如何获取flag?

#user.py
import secret

最简单的办法是py2的co_const

co_const属性，可以获得一个函数定义块中被定义的常量值
ast增加节点
那如果是Py3 或者 secret.py中的flag不以常量方式赋值怎么办呢
拿下面的secret.py举个例子，假设我们需要想办法获取flag的值

#secret.py
import uuid
def check():
  # Example
  flag = f"flag{{{uuid.uuid4()}}}"

现在我们允许读取文件，但是我们无法获取到uuid的值


我们可以修改ast树，在赋值的下面加一句print的ast树，然后调用ast的eval运行此函数


首先查看一个pring(flag)的ast节点

import ast
import astpretty
res = ast.parse("print(flag)")
astpretty.pprint(res)

Module(
    body=[
        Expr(
            lineno=1,
            col_offset=0,
            end_lineno=1,
            end_col_offset=11,
            value=Call(
                lineno=1,
                col_offset=0,
                end_lineno=1,
                end_col_offset=11,
                func=Name(lineno=1, col_offset=0, end_lineno=1, end_col_offset=5, id='print', ctx=Load()),
                args=[Name(lineno=1, col_offset=6, end_lineno=1, end_col_offset=10, id='flag', ctx=Load())],
                keywords=[],
            ),
        ),
    ],
    type_ignores=[],
)

我们模仿这个AST树，用python代码生成对应的ast结构

import ast
func = ast.Name(id="print", ctx=ast.Load())
args = [ast.Name(id="flag", ctx=ast.Load())]
call = ast.Call(func=func, args=args, keywords=[])
node = ast.Expr(value=call)

然后把我们自己生成的节点，插入到check函数中

content = open("secret.py").read()
res = ast.parse(content)
res.body[1].body.insert(1,node)
ast.fix_missing_locations(res)

由于print(flag)与赋值语句在同一层
而res.body[1]是函数定义结构，res.body[1].body即为函数体内，所以在此处插入res.body[1].body[0]是赋值语句，所以为insert(1,node)


ast.fix_missing_locations函数作用是自动修复 ast结构的偏移 行号等杂项，需要调用，否则会报
TypeError: required field "lineno" missing from stmt


最后只需要编译运行我们的ast树即可
exec(compile(res, '', 'exec'))


由于我们运行的语句相当于重新定义了一个check函数，所以还需要运行一遍check函数


整个文件结构如下

import ast
content = open("secret.py").read()
func = ast.Name(id="print", ctx=ast.Load())
args = [ast.Name(id="flag", ctx=ast.Load())]
call = ast.Call(func=func, args=args, keywords=[])
node = ast.Expr(value=call)
res = ast.parse(content)
res.body[1].body.insert(1,node)
ast.fix_missing_locations(res)
exec(compile(res, '', 'exec'))
check()

ast修改节点

除了可以在下一行新增节点以外，我们还可以直接修改赋值节点，直接改为表达式节点将值输出


跟上面差不多，就不多介绍了

import ast
content = open("secret.py").read()
res = ast.parse(content)
value = res.body[1].body[0].value
func = ast.Name(id="print", ctx=ast.Load())
args = [value]
call = ast.Call(func=func, args=args, keywords=[])
node = ast.Expr(value=call)
res.body[1].body[0] = node
ast.fix_missing_locations(res)
exec(compile(res, '', 'exec'))
check()

res.body[1].body[0].value 就是赋值表达式所赋的值

ast删除节点

body是一个list，把对应节点pop就行了

#secret.py
import uuid
def check():
  flag = f"flag{{{uuid.uuid4()}}}"
  flag = "88888"
  print(flag)
import ast
import astpretty
content = open("secret.py").read()
func = ast.Name(id="print", ctx=ast.Load())
args = [ast.Name(id="flag", ctx=ast.Load())]
call = ast.Call(func=func, args=args, keywords=[])
node = ast.Expr(value=call)
res = ast.parse(content)
res.body[1].body.pop(1)
ast.fix_missing_locations(res)
astpretty.pprint(res)
exec(compile(res, '', 'exec'))
check()

遍历节点

以上内容只是对某单一节点进行修改，如果我们要修改所有某一特征节点时如何去做。
ast库提供了 visit方法，供开发者遍历所有节点

import ast
content = open("secret.py").read()
res = ast.parse(content)
class MyVisit(ast.NodeVisitor):
def visit_Assign(self,node):
  print(node.value)
  return node
m = MyVisit()
m.visit(res)

<_ast.JoinedStr object at 0x02F2F6B8>
<_ast.Constant object at 0x02F2F928>

开发者需要定义一个ast.NodeVisitor的子类，然后定义对应的visit_结构类型方法，处理特定的结构。
然后创建这个类对象，调用visit方法。遍历AST树


但此类只能进行ast的输出，如果需要一边遍历一边修改ast，增删改等，就需要继承另一个子类ast.NodeTransformer
假如我们把所有常量数字改为字符串


我们先看看字符串和数字的ast结构

import ast
import astpretty
res = ast.parse("a = 123\nv='123'")
astpretty.pprint(res)

Module(
    body=[
        Assign(
            lineno=1,
            col_offset=0,
            end_lineno=1,
            end_col_offset=7,
            targets=[Name(lineno=1, col_offset=0, end_lineno=1, end_col_offset=1, id='a', ctx=Store())],
            value=Constant(lineno=1, col_offset=4, end_lineno=1, end_col_offset=7, value=123, kind=None),
            type_comment=None,
        ),
        Assign(
            lineno=2,
            col_offset=0,
            end_lineno=2,
            end_col_offset=7,
            targets=[Name(lineno=2, col_offset=0, end_lineno=2, end_col_offset=1, id='v', ctx=Store())],
            value=Constant(lineno=2, col_offset=2, end_lineno=2, end_col_offset=7, value='123', kind=None),
            type_comment=None,
        ),
    ],
    type_ignores=[],
)

Process finished with exit code 0

很明显，他们都属于Constant结构，完全对应里面的Value属性
需要注意的是，在老的python版本里，这些常量值分别属于
ast.Num, ast.Str而不是ast.Constant


所以这个数字转字符串的遍历类如下

#case.py
a = 123
b = "231445"
def s():
  c= 3124235213

#exp.py
import ast
import astunparse
content = open("case.py").read()
res = ast.parse(content)
class MyVisit(ast.NodeTransformer):
def visit_Constant(self,node):
  if type(node.value) == int:
    node.value = str(node.value)
  return node
m = MyVisit()
node = m.visit(res)
print(astunparse.unparse(node))

a = '123'
b = '231445'
def s():
  c = '3124235213'
Process finished with exit code 0

astunparse是一个三方库，将ast树转化为python code


而如果需要删除ast节点就更简单了，在方法里return None即可

Introductionas

https://stackoverflow.com/questions/46388130/insert-a-node-into-an-abstract-syntax-tree
https://www.escapelife.site/posts/40a2fc93.html

前言

如今大量前端开发皆采用现代化前端框架，如Vue和React，这类框架对于XSS提供了自带的防御措施，大部分情况下基本完全杜绝了XSS，但是在某些特定的场合下，依旧存在XSS风险，为了避免在一些渗透测试，安全服务中在这类框架上花无用的挖洞时间，此文来探讨一下此类框架是如何防御XSS以及如何产生XSS的
介于此，此文将尽可能少的介绍Vue和React的基础知识，不了解的读者可以视情况先学习一下前置知识在看此文

Vue

防御

我们知道，Vue采用数据绑定的方式，将变量绑定到dom树上，如下所示

<div id="app">
    <p>{{ message }}</p>
</div>

<script>
    new Vue({
        el: '#app',
        data: {
            message: 'Hello Vue.js!'
        }
    })
</script>

el代表dom的查询表达式，查询id=app的元素
然后将 {{}}里的message变量渲染为Hello Vue.js! 字符串
几乎所有的开发都这么写，那么假如我们message变量可控会如何

<div id="app">
    <p>{{ message }}</p>
</div>

<script>
    new Vue({
        el: '#app',
        data: {
            message: '<svg/onload=alert(1)>'
        }
    })
</script>

这里message被我们硬编码为了html代码，当然正常代码会动态给message赋值，这里效果一样，不额外举例，现在我们看看渲染的结果

可以看到，即使我们可控这些变量，开发者也没有做任何过滤，我们的xss payload依旧被转义为实体字符。
这就是vue底层做的事，vue对于变量绑定，底层其实是用了Javascript原生的innerText方法，而innerText默认会把所有html元素进行转义，由于innerText也是Js原生方法，当然正常情况不可能绕过

所以有时候，我们在某些系统里狂插payload，大家会发现没有一个弹窗，可能这不是开发者防御意识高，只是人家用了框架，攻击的方式错了

隐患1

如果开发者有将html代码作为值传入到变量中的需求呢，比如动态生成表格，对于一个大型框架来说，肯定有这种渲染标签的功能，
对于Vue来说，这个功能的指令叫V-html

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>Vue</title>
    <script src="https://cdn.staticfile.org/vue/2.2.2/vue.min.js"></script>
</head>
<body>
<div id="app">
    <p v-html="message"></p>
</div>

<script>
    new Vue({
        el: '#app',
        data: {
            message: '<svg/onload=alert(1)>'
        }
    })
</script>
</body>
</html>

很明显感觉到，v-html指令应该就是调用的document.innerHTML方法
如果开发者用v-html方法进行参数传递，并且参数可控，那么即可造成XSS

隐患2

vue用的最多的方法还是{{}},双大括号变量绑定，这个双大括号本质和 v-text指令是一样的，就是上面说的调用的innerText方法，对于一般的普通系统来说，几乎开发者全程使用{{}}进行参数传递，很少会额外用到v-html指令，那么如果不用v-html就没有常见的XSS问题了嘛？
对于一种很常见的XSS case，vue是没有做任何的防御的

<body>
<div id="app">
    <a :href="url">click me</a>
</div>

<script>
    new Vue({
        el: '#app',
        data: {
            url: "javascript:alert(111)"
        }
    })
</script>
</body>

a标签的属性xss，vue是没有任何防御措施的，我们只需要传入javascript:alert(1)即可触发XSS
除此以外
iframe的src属性，object标签的src属性都是可以触发XSS的


:href 其实是 v-bind:href的缩写
下面两个写法一样

    <a :href="url">click me</a>
    <a v-bind:href="url">click me</a>

隐患3

在javascript函数里面使用原生危险函数，比如innerHTML eval等，这个不再多说

React

React习惯用类语法来编写

隐患1

跟上诉href src一样，react不会对链接产生的xss进行过滤

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8" />
    <title>Hello React!</title>
    <script src="https://cdn.staticfile.org/react/16.4.0/umd/react.development.js"></script>
    <script src="https://cdn.staticfile.org/react-dom/16.4.0/umd/react-dom.development.js"></script>
    <script src="https://cdn.staticfile.org/babel-standalone/6.26.0/babel.min.js"></script>
</head>
<body>

<div id="example"></div>
<script type="text/babel">

    class WebSite extends React.Component {
        constructor() {
            super();

        }
        render() {
            return (
                <div>
                    <a href={this.props.site}>click me</a>
                </div>
            );
        }
    }
    ReactDOM.render(
        <WebSite site="javascript:alert(1)"/>,
        document.getElementById('example')
    );
</script>

</body>
</html>

隐患2

同样如上v-html，react也提供了一个渲染html的方法,不过这个办法名字比较吓人
dangerouslySetInnerHTML

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8" />
    <title>Hello React!</title>
    <script src="https://cdn.staticfile.org/react/16.4.0/umd/react.development.js"></script>
    <script src="https://cdn.staticfile.org/react-dom/16.4.0/umd/react-dom.development.js"></script>
    <script src="https://cdn.staticfile.org/babel-standalone/6.26.0/babel.min.js"></script>
</head>
<body>

<div id="example"></div>
<script type="text/babel">

    class WebSite extends React.Component {
        constructor() {
            super();

        }
        render() {
            return (
                <div>
                    <p dangerouslySetInnerHTML={{__html:this.props.site}}></p>
                </div>
            );
        }
    }
    ReactDOM.render(
        <WebSite site="<svg/onload=alert(1)>"/>,
        document.getElementById('example')
    );
</script>

</body>
</html>

这个dangerouslySetInnerHTML跟vue的v-html比较类似

隐患3

同上，使用原生函数

总结

了解这些会有什么帮助

白盒审计

如果我们在对前端项目进行审核的时候，如果发现前端项目是用vue或者react进行编写的话，我们就可以只关注上面的危险函数关键字，避开其他的常规功能，比如全局搜索 如下关键字

:href
v-bind:href
:src
v-bind:src
v-html
------------------------------
href={
src={
dangerouslySetInnerHTML=

------------------------------
innerHTML
eval(
....

黑盒审计

当然，大部分时候我们是没有源代码的，我们一般面对的是一个webpack打包后的构建产物js，如果有sourcemap泄露的话，我们就可以当上面白盒进行审计，如果在没有sourcemap泄露的情况下，就必须硬怼黑盒环境了，当然黑盒会有一些技巧
一般来说，Vue和React不会单独使用,大部分与现在前端常用的UI框架结合使用，比如Vue+elementUI，React+Antdesign


这类UI框架有个很明显的特征，一般常用于CRM系统，就是什么后台管理系统这类的，像这个样子





这种清一色的，左边上面菜单栏，中间内容，UI比较爽快的，大部分都是Vue+React的前端框架，所以在这里面疯狂扔<img src=#....是没有用的
正确的姿势是：
找输入链接的地方，比如网址，图片链接等输入框，插入javascript:alert(1)等，当然这里也有可能SSRF
找富文本，表格等，或者抓包发现往后端直接发送标签的地方，插入XSS poc
放弃掉其他功能，因为框架会做默认的转义