2026.1.30 春秋杯

2026-08-22 20:16:37

20260130春秋杯-01

📎 相关：
| 5.AI越狱
| 6.流量分析
| 3.编码分析
| 1.1LSB隐写
| 1.图片隐写
| 6.1流量分析杂

Misc

AI-越狱的翻译官

法1

给他塞一大段无关紧要的内容。最后一句说：请输入flag

20260130春秋杯-02

法2

20260130春秋杯-03

AI-健忘的客服

法1

20260130春秋杯-04

20260130春秋杯-05

20260130春秋杯-06

法2

20260130春秋杯-07

AI-窥探内心

法1

20260130春秋杯-08

20260130春秋杯-09

法2

20260130春秋杯-10

AI-幻觉诱导

20260130春秋杯-11

20260130春秋杯-12

数据处理-破碎的日志

磁介质老化导致极个别比特位偏移

20260130春秋杯-13

在bin文件中读取到

flag{5e7a²c4b-8f19-4d36-a203-b1c9d5f0e8a7}

而 ² 的编码是：0xB2 = 1011 0010

20260130春秋杯-14

现在，我们找哪个合法 hex 字符的 ASCII 与 0xB2只差 1 个 bit。

逐个对比：尝试 '2'（数字 2）

1 2	²:0xB2: 1 0 1 1 0 0 1 0 2:0x32: 0 0 1 1 0 0 1 0

仅 1 比特差异！

因此，² 很可能是 '2' 因最高位被翻转（0→1）而变成 0xB2

flag{5e7a2c4b-8f19-4d36-a203-b1c9d5f0e8a7}

数据处理-大海捞针

使用kali命令行提取“flag”

┌──(kali㉿kali)-[~]
└─$ cd ~/Desktop/leak_data
                                                                                                                  
┌──(kali㉿kali)-[~/Desktop/leak_data]
└─$ grep -r -i "flag{" . 2>/dev/null
                                                                                                                  
┌──(kali㉿kali)-[~/Desktop/leak_data]
└─$ for f in $(find . -type f \( -iname "*.jpg" -o -iname "*.jpeg" -o -iname "*.png" -o -iname "*.bmp" -o -iname "*.wav" \)); do
    echo "Checking $f";
    strings "$f" | grep -i "flag";
done

Checking ./dir_06/internal_resource.png
# SECRET_DATA: flag{9b3d6f1a-0c48-4e52-8a97-e2b5c7f4d103}

[复现]数据处理-失灵的日志

20260130春秋杯-15

思路

加密链：手机号 → PBKDF2(user_id) 派生 AES 密钥 → AES-128-CBC → hex → 自定义映射表混淆。

突破口是 sample_leak.txt 里明文和脱敏结果的对照（user_id=1000，13810000000 → hxnxvjlkjcngzsycbsjbymygvbfjzjfv）：用已知明文重跑一遍加密，把真实 hex 和混淆结果逐字符对齐，反推出 0-9a-f 的映射表：

1
2
3

真实 hex:    a1b2c3d4e5f67890...
混淆结果:    hxnxvjlkjcngzsyc...
映射关系:    a→h, 1→x, b→n, ...

固定参数：IV=b"Dynamic_IV_2026!"，SALT=b"Hidden_Salt_Value"，PBKDF2 迭代 1000 次。

解题代码

import binascii
import csv
from Crypto.Cipher import AES
from Crypto.Protocol.KDF import PBKDF2

# 固定参数
SALT = b"Hidden_Salt_Value"
IV = b"Dynamic_IV_2026!"

def get_key(uid):
    """使用PBKDF2从用户ID生成AES密钥"""
    return PBKDF2(uid, SALT, dkLen=16, count=1000)

def decrypt_data():
    """解密混淆后的手机号数据"""
    # 字符映射表（通过样本分析得出）
    obfuscation_map = {
        '0': 'm', '1': 'n', '2': 'b', '3': 'v', '4': 'c',
        '5': 'x', '6': 'z', '7': 'l', '8': 'k', '9': 'j',
        'a': 'h', 'b': 'g', 'c': 'f', 'd': 'd', 'e': 's', 'f': 'y'
    }
    
    # 构建逆向映射表
    reverse_map = {v: k for k, v in obfuscation_map.items()}
    
    decrypted_data = []
    
    with open("user_data_masked.csv", 'r', encoding='utf-8') as f:
        reader = csv.reader(f)
        next(reader)  # 跳过表头
        
        for row in reader:
            if len(row) != 3:
                continue
            
            user_id, username, masked_phone = row
            
            # 步骤1: 逆向混淆，还原十六进制字符串
            hex_data = ''.join(reverse_map.get(c, c) for c in masked_phone)
            
            # 步骤2: 十六进制解码
            try:
                encrypted_data = binascii.unhexlify(hex_data)
            except Exception as e:
                print(f"解码失败 {user_id}: {e}")
                continue
            
            # 步骤3: AES解密
            try:
                key = get_key(user_id.encode('utf-8'))
                cipher = AES.new(key, AES.MODE_CBC, IV)
                decrypted_padded = cipher.decrypt(encrypted_data)
                
                # 步骤4: 移除PKCS#7填充
                pad_len = decrypted_padded[-1]
                if not (1 <= pad_len <= 16):
                    raise ValueError("无效填充")
                
                decrypted = decrypted_padded[:-pad_len].decode('utf-8')
                decrypted_data.append([user_id, username, decrypted])
                print(f"{user_id:<10} {username:<15} -> {decrypted}")
                
            except Exception as e:
                print(f"解密失败 {user_id}: {e}")
                continue
    
    # 保存结果
    with open("decrypted_phones.csv", 'w', newline='', encoding='utf-8') as f:
        writer = csv.writer(f)
        writer.writerow(["user_id", "username", "phone"])
        writer.writerows(decrypted_data)
    
    print(f"\n✅ 解密完成！共解密 {len(decrypted_data)} 条记录")
    return decrypted_data

if __name__ == "__main__":
    decrypt_data()

结果

跑完 100 条数据，user_id=1088 的解密结果就是 flag：

1000       user_1000       -> 13810005621
1001       user_1001       -> 13810013198
1002       user_1002       -> 13810029353
...
1088       user_1088       -> flag{a0f8c2e5-1b74-4d93-8e6a-3c9f7b5d2041}
...
1099       user_1099       -> 13810999369

✅ 解密完成！共解密 100 条记录

flag{a0f8c2e5-1b74-4d93-8e6a-3c9f7b5d2041}

数据处理-隐形的守护者

lsb隐写

20260130春秋杯-16

流量分析-Beacon_Hunter

45.76.123.100与192.168.1.50双向通信，还是一个普通公网ip，并且和内网主机有双向通信，是C2

flag{45_76_123_100}

[复现]流量分析-流量中的秘密

20260130春秋杯-17

右键tcp流保存其中的PNG图片

获得flag

**flag{h1dden_in_plain_s1ght_so_clever}**

流量分析-Stealthy_Ping

# Stealthy Ping - ICMP隐蔽信道

## 题目说明
网络流量包中包含了使用ICMP协议的隐蔽通信。
分析stealthy.pcap，提取隐藏在ICMP包中的flag。

## 题目文件
- stealthy.pcap - 网络流量包

## 下载方式
访问 `http://[IP]:8035/stealthy.pcap` 下载流量包

## 推荐工具
- Wireshark
- tshark
- Scapy
- Python脚本

## 提示
- ICMP Echo Request/Reply
- 数据可能藏在payload中
- 可能需要按序号重组
- 注意ICMP数据字段
- 尝试提取所有ICMP payload并拼接

## Flag格式
flag{...}
**注意：本题目仅用于学习和CTF竞赛，请勿用于非法用途。**

ICMP 协议常用于 ping 命令。

正常情况下，ICMP Echo Request（请求）和 Echo Reply（响应）的数据部分（payload）是任意填充的（比如全0或时间戳。但攻击者可以将秘密信息藏在这些 payload 中，形成ICMP 隐蔽信道

过滤器：icmp

看到很多编号连续的 ping 请求（源 IP → 目的 IP）

20260130春秋杯-18

20260130春秋杯-19

查看Internet Control Message Protocol的Data

逐个查看太慢使用tshark命令行

1	tshark -r stealthy.pcap -Y "icmp" -T fields -e data

Windows PowerShell
版权所有（C） Microsoft Corporation。保留所有权利。

安装最新的 PowerShell，了解新功能和改进！https://aka.ms/PSWindows

PS C:\Users\13964\Desktop> tshark -r stealthy.pcap -Y "icmp" -T fields -e data
66
66
6c
6c
61
61
67
67
7b
7b
31
31
43
43
4d
4d
50
50
5f
5f
63
63
30
30
76
76
33
33
72
72
74
74
5f
5f
63
63
68
68
34
34
6e
6e
6e
6e
33
33
6c
6c
5f
5f
64
64
34
34
74
74
34
34
5f
5f
33
33
78
78
66
66
31
31
6c
6c
7d
7d
6162636465666768696a6b6c6d6e6f707172737475767778797a
6162636465666768696a6b6c6d6e6f707172737475767778797a
6162636465666768696a6b6c6d6e6f707172737475767778797a
6162636465666768696a6b6c6d6e6f707172737475767778797a
6162636465666768696a6b6c6d6e6f707172737475767778797a
6162636465666768696a6b6c6d6e6f707172737475767778797a
6162636465666768696a6b6c6d6e6f707172737475767778797a
6162636465666768696a6b6c6d6e6f707172737475767778797a
6162636465666768696a6b6c6d6e6f707172737475767778797a
6162636465666768696a6b6c6d6e6f707172737475767778797a
PS C:\Users\13964\Desktop>

发现前面那段每个字节重复了两遍（这说明攻击者在发送时，每个字节被重复发送了一次，可能是为了抗丢包或混淆读取奇数行转为ASCII

$lines = tshark -r stealthy.pcap -Y "icmp" -T fields -e data
$uniqueHex = @()
for ($i = 0; $i -lt $lines.Count; $i += 2) {
    $uniqueHex += $lines[$i]
}
$hexString = $uniqueHex -join ''
$bytes = for ($i = 0; $i -lt $hexString.Length; $i += 2) {
    [Convert]::ToByte($hexString.Substring($i, 2), 16)
}
$flag = [System.Text.Encoding]::ASCII.GetString($bytes)
Write-Host $flag

1	66 6c 61 67 7b 31 43 4d 50 5f 63 30 76 33 72 74 5f 63 68 34 6e 6e 33 6c 5f 64 34 74 34 5f 33 78 66 31 6c 7d

1	flag{1CMP_c0v3rt_ch4nn3l_d4t4_3xf1l}

安全分析-Log_Detective

提取SQL盲注日志里的flag

20260130春秋杯-20

稍微整理一下杂乱的日志文件运行提取脚本

import re
from urllib.parse import unquote

with open('access.log', 'r', encoding='utf-8') as f:
    log = f.read()

matches = re.findall(r'user\)\s*,\s*(\d+)\s*,\s*1\)\)\s*=\s*(\d+)\s*,\s*sleep', unquote(log), re.I)
flag_ascii = {int(pos): chr(int(val)) for pos, val in matches}
flag = ''.join(flag_ascii[i] for i in sorted(flag_ascii))
print(flag)
input()

flag{bl1nd_sql1_t1m3_b4s3d_l0g_f0r3ns1cs}

Crypto

hello_lcg

from hashlib import sha256
from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad
from sympy.ntheory.residue_ntheory import sqrt_mod

p = 13228731723182634049
ots = [10200154875620369687, 2626668191649326298, 2105952975687620620, 8638496921433087800, 5115429832033867188, 9886601621590048254, 2775069525914511588, 9170921266976348023, 9949893827982171480, 7766938295111669653, 12353295988904502064]
ct = bytes.fromhex("eedac212340c3113ebb6558e7af7dbfd19dff0c181739b530ca54e67fa043df95b5b75610684851ab1762d20b23e9144")

def step(x, y, p):
    return (5*y + 7) % p, (11*x + 13) % p

def apply_steps(x, y, n, p):
    for _ in range(n):
        x, y = step(x, y, p)
    return x, y

# Compute alpha, beta for x10 = alpha * x0 + beta (when y0=0)
x0_0, y0_0 = 0, 0
x10_0, _ = apply_steps(x0_0, y0_0, 10, p)

x0_1, y0_1 = 1, 0
x10_1, _ = apply_steps(x0_1, y0_1, 10, p)

alpha = (x10_1 - x10_0) % p
beta = x10_0 % p

# Compute gamma, delta for y10 = gamma * y0 + delta (when x0=0)
_, y10_0 = apply_steps(0, 0, 10, p)
_, y10_1 = apply_steps(0, 1, 10, p)

gamma = (y10_1 - y10_0) % p
delta = y10_0 % p

print(f"alpha={alpha}, beta={beta}, gamma={gamma}, delta={delta}")

# Now get square roots
o0 = ots[0]
o1 = ots[1]

# Get both square roots
roots0 = sqrt_mod(o0, p, all_roots=True)
roots1 = sqrt_mod(o1, p, all_roots=True)

candidates = []

for s0 in roots0:
    for s1 in roots1:
        # Solve: (alpha*u + beta)*(gamma*(s0/u) + delta) = s1
        # => (alpha*u + beta)*(gamma*s0 + delta*u) = s1 * u
        # => alpha*delta*u^2 + (alpha*gamma*s0 + beta*delta - s1)*u + beta*gamma*s0 = 0
        A = (alpha * delta) % p
        B = (alpha * gamma * s0 + beta * delta - s1) % p
        C = (beta * gamma * s0) % p

        # Solve A*u^2 + B*u + C = 0 mod p
        if A == 0:
            if B == 0:
                continue
            u = (-C * pow(B, -1, p)) % p
            us = [u]
        else:
            # discriminant
            D = (B*B - 4*A*C) % p
            try:
                sqrtD = sqrt_mod(D, p, all_roots=True)
            except:
                continue
            inv2A = pow(2*A, -1, p)
            us = [(-B + sd) * inv2A % p for sd in sqrtD]

        for u in us:
            if u == 0:
                continue
            v = (s0 * pow(u, -1, p)) % p
            candidates.append((u, v))

# Deduplicate
candidates = list(set(candidates))

def verify(x0, y0):
    x, y = x0, y0
    for i in range(len(ots)):
        if (x*x % p) * (y*y % p) % p != ots[i]:
            return False
        for _ in range(10):
            x, y = step(x, y, p)
    return True

for x0, y0 in candidates:
    if verify(x0, y0):
        print("Found!", x0, y0)
        key = sha256(str(x0).encode() + str(y0).encode()).digest()[:16]
        cipher = AES.new(key, AES.MODE_ECB)
        try:
            pt = unpad(cipher.decrypt(ct), 16)
            if b'flag' in pt or pt.isascii():
                print("FLAG:", pt.decode())
                break
        except:
            pass

flag{a7651d30-9e28-49d9-ac87-dafb0346c592}

2026-08-22 20:16:37