前言：
水区的朋友们，年轻就是资本，和我一起学逆向逆天改命吧，我的学习过程全部记录及学习资源：https://www.52pojie.cn/forum.php?mod=viewthread&tid=2093516&page=1#pid54862410
立帖为证！--------记录学习的点点滴滴
0x1 环境准备
1.题目在这里下载：https://adworld.xctf.org.cn/，攻防世界-历年真题-精选免费练习题-reserve方向-crackeme。
2.题目提示魔改tea，换表，原本是不敢尝试的，但是现在有了AI想大胆试试，那么首先得问问deepseek了解一下这两个概念，这里只摘录一部分：
TEA (Tiny Encryption Algorithm) 是一种对称加密算法，特点是：
- 简单小巧，代码量极少
- 使用128位密钥（4个32位整数）
- 对64位数据块（2个32位整数）进行加密
标准TEA加密流程
// 标准TEA加密
void tea_encrypt(uint32_t *v, uint32_t *k) {
uint32_t v0 = v[0], v1 = v[1];
uint32_t sum = 0;
uint32_t delta = 0x9e3779b9; // 魔数，黄金分割比例
for (int i = 0; i < 32; i++) {
sum += delta;
v0 += ((v1 << 4) + k[0]) ^ (v1 + sum) ^ ((v1 >> 5) + k[1]);
v1 += ((v0 << 4) + k[2]) ^ (v0 + sum) ^ ((v0 >> 5) + k[3]);
}
v[0] = v0; v[1] = v1;
}
换表指的是：
换delta表
// 标准：固定delta值
// 魔改：使用delta数组
uint32_t delta_table[] = {0x11111111, 0x22222222, 0x33333333, ...};
3.这个程序得到linux环境下运行，我的电脑上有虚拟机和kali，接下来就是配置远程调试环境了。
1）查壳可以看到是amd64也就是64位的linux程序，接下来将ida目录下dbgsrv目录下的linux_server64拷贝到我的kali中，按照deepseek告诉我的步骤操作。
# 复制IDA的64位server到Linux
# IDA安装目录/dbgsrv/linux_server（64位版本）
# 赋予执行权限
chmod +x linux_server
# 运行（默认端口23946）
./linux_server
# 可选：带密码运行
./linux_server -P yourpassword
2）IDA连接设置
Debugger → Select debugger → Remote Linux debugger
Debugger → Process options
关键参数：
Application: /home/user/target_program（Linux中绝对路径）
Directory: /home/user/（工作目录）
Parameters: 程序参数（如有）
Hostname: Linux虚拟机IP（如192.168.1.100）
Port: 23946
4.测试一下ida是否配置成功，连接成功了，出现了一个警告，没有符号表，先不管了。
0x2 逆向分析
1.打开ida的string视图，看到input，flag{，error字样，先从error分析，看能不能找到正确流程，点进去点进去到了data段，Ctrl+X查看交叉引用表，随便点一个跳转过去，好在程序流程图比较简单，右侧看到ok字样，猜测是成功的分支。
2.找到调用链,去F5反编译一下，sub_400D6A这里就是关键函数了，在他前面的几个函数也需要关注，里面代码F5也看了，奈何还是看不懂，接下来该看deepseek的能力了：
loc_400D43<-loc_400D18这里右侧循环完才会走左侧<-loc_400C5A<-loc_400C11<-loc_400BD6<-sub_400ADF
v13 = __readfsqword(0x28u);
sub_410E10(off_6CB848, 0LL, 2LL, 0LL);
sub_410E10(off_6CB840, 0LL, 2LL, 0LL);
sub_410E10(off_6CB838, 0LL, 2LL, 0LL);
sub_410410((unsigned int)"input: ", 0, v0, v1, v2, v3);
sub_440790(0LL, v9, 256LL);
v8 = (_BYTE *)sub_400380(v9, 10LL);
if ( v8 )
*v8 = 0;
if ( (unsigned int)sub_400330(v9, "flag{", 5LL) )
goto LABEL_11;
v7 = sub_424C60(v9);
if ( v9[v7 - 1] != 125 )
goto LABEL_11;
v9[v7 - 1] = 0;
if ( sub_424C60(v10) != 16 )
goto LABEL_11;
sub_42D630(v12, "nice2you", 8LL);
sub_4009AE(v10, v11);
v4 = sub_424C60(v10);
sub_400A8C(v10, v4, &unk_6CB0A0);
for ( i = 0; i <= 7; ++i )
v10[i + 8] ^= v10[i];
if ( (unsigned __int8)sub_400D6A(v10) == 1 )
{
sub_410C40("ok");
result = 0LL;
}
else
{
LABEL_11:
result = sub_410C40("error");
}
if ( __readfsqword(0x28u) != v13 )
sub_4440D0();
return result;
}
3.直接将一整段sub_400ADF汇编代码全部丢给deepseek，提示还需要三个关键信息，然后提供。
需要你提供的信息
为了继续分析，请提供：
sub_4009AE 的完整反汇编代码
unk_6CB0A0 处的16字节数据（在IDA中双击这个地址查看）
sub_400D6A 的代码（最终验证函数）
4.sub_4009AE和sub_400D6A直接看汇编代码提供，unk_6CB0A0数据双击进数据段，复制数据过来，然后经过漫长的等待，deepseek还是不能帮我算出flag，当然它还是分析出不少东西了：
1）flag必须是flag{开头，}结尾
2）花括号内的内容，长度必须为16
关键函数调用
sub_42D630(v12, "nice2you", 8LL); // 设置密钥为"nice2you"
sub_4009AE(v10, &v11); // 可能是初始化或转换函数
v4 = sub_424C60(v10);
sub_400A8C(v10, v4, &byte_6CB0A0); // 关键加密/处理函数
验证函数，sub_400D6A是线性方程。
if ( (unsigned __int8)sub_400D6A是线性方程。(v10) == 1 )
// 输出"ok" - 正确
else
// 输出"error" - 错误
5.就我这阅读代码的能力也看不出什么了，打上断点IDA动调走起，太长时间没操作了，查一下IDA动态调试快捷键。
| 操作 |
快捷键 |
说明 |
| 开始调试 |
F9 |
运行程序直到断点或结束 |
| 单步步入 |
F7 |
进入函数内部（Step Into） |
| 单步跳过 |
F8 |
不进入函数，执行到下一行（Step Over） |
| 执行到返回 |
Ctrl+F7 |
执行直到当前函数返回 |
| 执行到光标处 |
F4 |
运行到光标所在位置 |
| 暂停 |
F2 |
暂停程序执行 |
| 停止调试 |
Ctrl+F2 |
结束调试会话 |
| 设置/取消断点 |
F2 |
在光标所在行设置断点 |
| 显示断点列表 |
Ctrl+Alt+B |
管理所有断点 |
| 窗口 |
快捷键 |
作用 |
| 寄存器窗口 |
Ctrl+Alt+R |
查看CPU寄存器值 |
| 栈窗口 |
Ctrl+Alt+K |
查看调用栈 |
| 局部变量 |
Ctrl+Alt+L |
查看局部变量 |
| 内存窗口 |
Ctrl+Alt+M |
查看内存数据 |
| 监视窗口 |
Ctrl+Alt+W |
添加监视表达式 |
6.一路跟着伪代码调试，可以看到v9是我们输入的flag{1234567890123456},v10是取花括号中的那一串，sub_42D630这个函数是把nice2you拼接到v10。sub_4009AE传了原字符串前8位和后8位进去，nice2you这个似乎没参与运算，处理后的数据如下，只处理了前8位。
[stack]:00007FFDBF1B10D0 db 66h ; f
[stack]:00007FFDBF1B10D1 db 6Ch ; l
[stack]:00007FFDBF1B10D2 db 61h ; a
[stack]:00007FFDBF1B10D3 db 67h ; g
[stack]:00007FFDBF1B10D4 db 7Bh ; {
[stack]:00007FFDBF1B10D5 db 2Bh ; +
[stack]:00007FFDBF1B10D6 db 2
[stack]:00007FFDBF1B10D7 db 0AFh
[stack]:00007FFDBF1B10D8 db 8Bh
[stack]:00007FFDBF1B10D9 db 0F7h
[stack]:00007FFDBF1B10DA db 77h ; w
[stack]:00007FFDBF1B10DB db 98h
[stack]:00007FFDBF1B10DC db 5Ch ; \
[stack]:00007FFDBF1B10DD db 39h ; 9
[stack]:00007FFDBF1B10DE db 30h ; 0
[stack]:00007FFDBF1B10DF db 31h ; 1
[stack]:00007FFDBF1B10E0 db 32h ; 2
[stack]:00007FFDBF1B10E1 db 33h ; 3
[stack]:00007FFDBF1B10E2 db 34h ; 4
[stack]:00007FFDBF1B10E3 db 35h ; 5
[stack]:00007FFDBF1B10E4 db 36h ; 6
[stack]:00007FFDBF1B10E5 db 6Eh ; n
[stack]:00007FFDBF1B10E6 db 69h ; i
[stack]:00007FFDBF1B10E7 db 63h ; c
[stack]:00007FFDBF1B10E8 db 65h ; e
[stack]:00007FFDBF1B10E9 db 32h ; 2
[stack]:00007FFDBF1B10EA db 79h ; y
[stack]:00007FFDBF1B10EB db 6Fh ; o
[stack]:00007FFDBF1B10EC db 75h ; u
[stack]:00007FFDBF1B10ED db 0
7.经过v4 = sub_424C60(v10);这句代码后，v4等于0x18，也就是24。接下来 sub400A8C函数，这里传了v10，v4，还有一个byte_6CB0A0，这个函数进去是一个for循环，循环次数是v4，每次变换后v10的值会变化，看上去似乎a3的值没有循环，每次都是加0x25吗？问问deepseek。
这个函数做的是：
*(unsigned __int8 *)(a1 + i) - 取出输入的第 i 个字节（作为索引）
+ a3 - 加上 S盒的基地址
*(_BYTE *)(...) - 从 S盒中取出对应位置的值
写回到 a1 + i - 替换原字节
这里让AI整理一下S盒数据
.data:00000000006CB0A0 byte_6CB0A0 db
0x25, 0x3A, 0x4C, 0x27, 0x8E, 0x5F, 0xA8, 0xC5, 0x20, 0xC2, 0xFF, 0x8B, 0x28, 0x30, 0xB4, 0x3C,
0x19, 0xC0, 0x2F, 0x6A, 0x65, 0x24, 0x8C, 0x13, 0x7E, 0xF6, 0x3E, 0x17, 0xDD, 0x89, 0x55, 0x82,
0x57, 0x03, 0xF1, 0xE1, 0x3D, 0xB8, 0x31, 0x67, 0x00, 0x22, 0x2D, 0xA7, 0x32, 0x58, 0x8F, 0xCF,
0x78, 0x39, 0x73, 0x44, 0x34, 0xD8, 0x77, 0x12, 0x88, 0xF5, 0x51, 0x75, 0xC9, 0x7F, 0x7B, 0x0F,
0xE5, 0xF8, 0x6E, 0xE2, 0x83, 0x05, 0x47, 0x72, 0xFE, 0xE0, 0xF7, 0xF0, 0x04, 0x9A, 0x80, 0x1C,
0x8D, 0xEF, 0x4E, 0x33, 0xAA, 0x66, 0x9C, 0x37, 0xB1, 0x21, 0x85, 0x1D, 0xAF, 0x81, 0x42, 0x5B,
0xC7, 0x9D, 0xE6, 0x38, 0x8A, 0x49, 0x7A, 0xAE, 0xD0, 0xDF, 0xFB, 0x79, 0x18, 0xDC, 0xF3, 0xA5,
0x59, 0x29, 0xEB, 0xB0, 0x0D, 0x43, 0xEC, 0xEE, 0xCC, 0x2E, 0xF9, 0x08, 0x74, 0x5E, 0x50, 0xBA,
0xE4, 0x61, 0xA6, 0x14, 0x54, 0xE8, 0xDB, 0xB5, 0xFA, 0xD9, 0xED, 0xA3, 0x01, 0xB3, 0x11, 0x2B,
0x96, 0x6F, 0x52, 0x36, 0x23, 0x16, 0x1E, 0xF2, 0x40, 0x6C, 0x48, 0x35, 0x9E, 0xB9, 0x45, 0xC3,
0x02, 0x7D, 0x97, 0x94, 0x4A, 0xD1, 0x95, 0xCB, 0xC4, 0x2C, 0xA4, 0x15, 0x07, 0xBD, 0xA2, 0xAB,
0x9F, 0xB6, 0x9B, 0xFD, 0xB2, 0x53, 0x64, 0x5A, 0xDE, 0x0B, 0x70, 0xBE, 0x76, 0xE9, 0x4D, 0xBF,
0xEA, 0xF4, 0xAC, 0x86, 0x0C, 0x6B, 0x63, 0x5C, 0x71, 0x91, 0x2A, 0x3B, 0x09, 0x90, 0xFC, 0x98,
0x46, 0xA9, 0x69, 0xB7, 0xD7, 0xDA, 0xC1, 0x93, 0xC8, 0xD4, 0x06, 0x4F, 0x62, 0x6D, 0x3F, 0xBC,
0x92, 0x84, 0x26, 0x68, 0x60, 0xE3, 0xD6, 0xC6, 0xCA, 0x1A, 0xCE, 0xAD, 0x10, 0x1F, 0xBB, 0x41,
0x7C, 0xA0, 0x5D, 0x0E, 0x1B, 0x99, 0xE7, 0x4B, 0xD2, 0xCD, 0x0A, 0xD3, 0xA1, 0x87, 0xD5, 0x56
8.已经这里循环24次，那就是每次从这里面byte_6CB0A0取出一个字节，逐个给v10，看第一个字符2B对应S盒索引43也就是第44个元素，也就是A7，接下来继续看for循环，deepseek告诉我这个XOR操作是：将第8-15字节与第0-7字节进行XOR。
[stack]:00007FFDBF1B10D0 db 66h ; f
[stack]:00007FFDBF1B10D1 db 6Ch ; l
[stack]:00007FFDBF1B10D2 db 61h ; a
[stack]:00007FFDBF1B10D3 db 67h ; g
[stack]:00007FFDBF1B10D4 db 7Bh ; {
[stack]:00007FFDBF1B10D5 db 0A7h
[stack]:00007FFDBF1B10D6 db 4Ch ; L
[stack]:00007FFDBF1B10D7 db 0ABh
[stack]:00007FFDBF1B10D8 db 0A3h
[stack]:00007FFDBF1B10D9 db 4Bh ; K
[stack]:00007FFDBF1B10DA db 0EEh
[stack]:00007FFDBF1B10DB db 40h ; @
[stack]:00007FFDBF1B10DC db 0AFh
[stack]:00007FFDBF1B10DD db 0F5h
[stack]:00007FFDBF1B10DE db 78h ; x
[stack]:00007FFDBF1B10DF db 39h ; 9
[stack]:00007FFDBF1B10E0 db 73h ; s
[stack]:00007FFDBF1B10E1 db 44h ; D
[stack]:00007FFDBF1B10E2 db 34h ; 4
[stack]:00007FFDBF1B10E3 db 0D8h
[stack]:00007FFDBF1B10E4 db 77h ; w
[stack]:00007FFDBF1B10E5 db 0F3h
[stack]:00007FFDBF1B10E6 db 0DFh
[stack]:00007FFDBF1B10E7 db 38h ; 8
[stack]:00007FFDBF1B10E8 db 49h ; I
[stack]:00007FFDBF1B10E9 db 73h ; s
[stack]:00007FFDBF1B10EA db 2Eh ; .
[stack]:00007FFDBF1B10EB db 0A5h
[stack]:00007FFDBF1B10EC db 43h ; C
9.这个for循环F4过去后再看看v10的数据，根据对比，可以看出AI推断的没有问题，就是第9-16位与前8位做了一个异或操作。
[stack]:00007FFDBF1B10D0 db 66h ; f
[stack]:00007FFDBF1B10D1 db 6Ch ; l
[stack]:00007FFDBF1B10D2 db 61h ; a
[stack]:00007FFDBF1B10D3 db 67h ; g
[stack]:00007FFDBF1B10D4 db 7Bh ; {
[stack]:00007FFDBF1B10D5 db 0A7h
[stack]:00007FFDBF1B10D6 db 4Ch ; L
[stack]:00007FFDBF1B10D7 db 0ABh
[stack]:00007FFDBF1B10D8 db 0A3h
[stack]:00007FFDBF1B10D9 db 4Bh ; K
[stack]:00007FFDBF1B10DA db 0EEh
[stack]:00007FFDBF1B10DB db 40h ; @
[stack]:00007FFDBF1B10DC db 0AFh
[stack]:00007FFDBF1B10DD db 52h ; R
[stack]:00007FFDBF1B10DE db 34h ; 4
[stack]:00007FFDBF1B10DF db 92h
[stack]:00007FFDBF1B10E0 db 0D0h
[stack]:00007FFDBF1B10E1 db 0Fh
[stack]:00007FFDBF1B10E2 db 0DAh
[stack]:00007FFDBF1B10E3 db 98h
[stack]:00007FFDBF1B10E4 db 0D8h
[stack]:00007FFDBF1B10E5 db 0F3h
[stack]:00007FFDBF1B10E6 db 0DFh
[stack]:00007FFDBF1B10E7 db 38h ; 8
[stack]:00007FFDBF1B10E8 db 49h ; I
[stack]:00007FFDBF1B10E9 db 73h ; s
[stack]:00007FFDBF1B10EA db 2Eh ; .
[stack]:00007FFDBF1B10EB db 0A5h
[stack]:00007FFDBF1B10EC db 43h ; C
10.接下来就是sub400D6A最后一道验证了，前面AI判断是一个线性方程,让deepseek写一个脚本解密。
0xa8,0x9f,0x51,0x70,0x71,0x09,0xed,0x73,0xf1,0xab,0x89,0xa8,0x49,0x71,0x67,0x37
11.现在有了最终的v10，再让ai帮忙写找flag脚本，输出结果包含不可见字符，显然脚本还是有问题，到底是前面方程解的有问题还是逆推有问题呢？直接在sub400D6A下断点跑一遍，执行这个函数前patch把上面的16进制数据替换进去，可以看到程序执行输出ok，说明这个方程求解是没问题的。让deepseek告诉我们步骤吧，看看是不是步骤出了问题。
原始flag (16字节)
↓ S盒替换 (sub_400A8C)
S盒输出 (16字节)
↓ XOR操作 (后8字节 ^= 前8字节)
验证输入 (16字节) ← 你提供的这个
这推理不对，告诉它前面还有个函数sub_4009AE这一步逆向，修正后的工作流。
原始flag (16字节)
↓
sub_4009AE (TEA加密，密钥"nice2you")
↓
加密后的数据 (16字节)
↓
S盒替换 (sub_400A8C)
↓
XOR操作 (后8字节 ^= 前8字节)
↓
验证 (sub_400D6A的线性方程组)
12.然而还是写不出flag，难道要止步于此了，一步步来找错，
后8字节与前8字节再次异或，然后利用S盒找到之前的16进制数据，先验证这个数据对不对，一样的下断点，通过。
6 b0 3a ba c8 cc 8a 32 70 34 35 35 63 30 64 33
13.接下来还剩一个tea解密脚本，ai写的解密脚本不对，似乎卡在这一步了，再给他说一下，动调调试时只处理了前8位，而且原始输入字符串会拼接nice2you。
原始flag (16字节)
↓
TEA加密前8字节 (密钥"nice2you")
↓
加密后的16字节: [加密的前8字节] + [原始后8字节]
↓
S盒替换 (全部16字节)
↓
XOR操作 (后8字节 ^= 前8字节)
↓
验证
14.然而还是不对，人麻了啊，再看看密钥"nice2you"，不对，这个流程不对，密钥应该是p455c0d3nice2you啊，n小时后终于写出了脚本，要疯了，下面给出不断纠错的提示词。
内存存储（小端序）：
当把4个字节作为32位整数存储时，小端序会将低地址存低字节，高地址存高字节。
求求你了，小端序存储，不要交换字节啊
密钥是p455c0d3nice2you不是nice2you啊
咋又把后8位加密，后8位和nice2you拼在一起是密钥的，ida动调时发现只改了前8位
6 b0 3a ba c8 cc 8a 32 左边是要加密的，右边70 34 35 35 63 30 64 33你不要动啊
6 b0 3a ba c8 cc 8a 32 70 34 35 35 63 30 64 33这是tea函数sub_4009AE 的输出，后面用它验证可以通过，不要管后面S盒变换了。
你就看sub_4009AE函数行不行，密钥p455c0d3nice2you，要加密的数据6 b0 3a ba c8 cc 8a 32，小端序存储。
15.跑一下最终的py脚本，可算解出flag了。
import struct
def tea_decrypt(data, key):
"""
解密8字节数据块
data: 8字节密文
key: 16字节密钥
"""
# 转换为32位整数（小端序）
v3 = struct.unpack('<I', data[0:4])[0]
v4 = struct.unpack('<I', data[4:8])[0]
# 密钥转换
k0 = struct.unpack('<I', key[0:4])[0]
k1 = struct.unpack('<I', key[4:8])[0]
k2 = struct.unpack('<I', key[8:12])[0]
k3 = struct.unpack('<I', key[12:16])[0]
delta = 0x12345678
sum_val = (delta * 32) & 0xFFFFFFFF
for _ in range(32):
# 先恢复v4
v4 = (v4 - ((v3 + sum_val) ^ ((16 * v3 + k2) & 0xFFFFFFFF) ^ ((v3 >> 5) + k3))) & 0xFFFFFFFF
# 再恢复v3
v3 = (v3 - ((v4 + sum_val) ^ ((16 * v4 + k0) & 0xFFFFFFFF) ^ ((v4 >> 5) + k1))) & 0xFFFFFFFF
sum_val = (sum_val - delta) & 0xFFFFFFFF
return struct.pack('<I', v3) + struct.pack('<I', v4)
# ============================================================
# 主解密函数
# ============================================================
def main():
print("=" * 60)
print("从TEA加密数据解密Flag")
print("=" * 60)
# TEA加密后的数据（从堆栈）
# 前8字节是加密的，后8字节是原始的（未加密）
tea_encrypted = bytes.fromhex("06b03abac8cc8a327034353563306433")
print(f"\n[1] TEA加密数据: {tea_encrypted.hex()}")
print(f" 前8字节（加密）: {tea_encrypted[:8].hex()}")
print(f" 后8字节（原始）: {tea_encrypted[8:].hex()} -> {tea_encrypted[8:].decode('ascii')}")
# 密钥 "p455c0d3nice2you"
key = b"p455c0d3nice2you"
print(f"\n[2] 密钥: {key}")
print(f" 密钥十六进制: {key.hex()}")
# TEA解密 - 只解密前8字节
print(f"\n[3] TEA解密前8字节:")
print("-" * 40)
cipher_first = tea_encrypted[:8]
plain_first = tea_decrypt(cipher_first, key)
print(f" 密文: {cipher_first.hex()}")
print(f" 解密: {plain_first.hex()} -> {plain_first}")
# 后8字节保持不变
plain_second = tea_encrypted[8:]
print(f" 后8字节: {plain_second.hex()} -> {plain_second.decode('ascii')}")
# 组合完整flag
full_flag_bytes = plain_first + plain_second
print(f"\n[4] 完整flag字节: {full_flag_bytes.hex()}")
# 解码为字符串
print("\n" + "=" * 60)
print("解码结果:")
print("=" * 60)
# 直接解码（小端序字节就是正确的顺序）
try:
flag_str = full_flag_bytes.decode('ascii')
print(f"✅ Flag: flag{{{flag_str}}}")
except UnicodeDecodeError:
# 如果直接解码失败，尝试每个4字节组逆序
print("直接解码失败，尝试小端序字节逆序...")
part1 = plain_first[:4][::-1]
part2 = plain_first[4:8][::-1]
part3 = plain_second[:4][::-1]
part4 = plain_second[4:8][::-1]
flag_str = (part1 + part2 + part3 + part4).decode('ascii')
print(f"✅ Flag: flag{{{flag_str}}}")
print("=" * 60)
# ============================================================
# 运行
# ============================================================
if __name__ == "__main__":
main()
C:\Users\LENOVO>C:\Users\LENOVO\Desktop\deepseek_python_20260328_12e8d8.py
============================================================
从TEA加密数据解密Flag
============================================================
[1] TEA加密数据: 06b03abac8cc8a327034353563306433
前8字节（加密）: 06b03abac8cc8a32
后8字节（原始）: 7034353563306433 -> p455c0d3
[2] 密钥: b'p455c0d3nice2you'
密钥十六进制: 70343535633064336e69636532796f75
[3] TEA解密前8字节:
----------------------------------------
密文: 06b03abac8cc8a32
解密: 7930755f6730745f -> b'y0u_g0t_'
后8字节: 7034353563306433 -> p455c0d3
[4] 完整flag字节: 7930755f6730745f7034353563306433
============================================================
解码结果:
============================================================
✅ Flag: flag{y0u_g0t_p455c0d3}
0x3 总结
1、今天又是和deepseek斗智的一天，编程基础薄弱啊，脑子里左思右想，就是写不出逆推代码，刚开始还以为ai逻辑错了。
2、干到最后才发现，按它的要求一步步分析，结果喂过它，还给我错误的工作流，还老喜欢幻想，没叫它动别的非得动。
3、最后来一句deepseek真香，辅助效果还是很强的。
[复制链接]
发表于 2026-3-28 16:42
分享到朋友圈
