目录

逆向工程中的 “字符串与算法” 破解：从静态分析到动态调试

一、静态分析：用工具 “读” 懂程序的 “语言”

1. 静态分析工具：从入门到进阶

核心工具选型

工具实战：用 IDA Pro 提取关键信息

2. 加密算法识别：从代码特征 “猜” 算法

对称加密（AES、DES）

非对称加密（RSA）

哈希算法（MD5、SHA-1）

二、动态调试：让程序 “说” 出中间结果

1. 调试工具：从 GDB 到 x64dbg

主流调试工具

GDB+pwndbg 实战：破解校验逻辑

x64dbg 实战：追踪动态密钥

三、算法破解：从输入输出推导加密逻辑

1. 异或加密：最常见的 “入门级” 算法

2. 自定义算法：从 “黑盒测试” 到 “白盒还原”

四、反调试与绕过：让程序 “允许” 被调试

1. 常见反调试手段识别

2. 绕过技巧：从 Patch 到调试器设置

五、实战总结：逆向解题的 “黄金流程”

逆向工程中的 “字符串与算法” 破解：从静态分析到动态调试（续）

六、高级算法逆向：AES 与 RSA 的实战破解

1. AES 加密的逆向：从 S 盒到密钥扩展

实战案例：AES-ECB 模式破解（无填充）

2. RSA 加密的逆向：从大素数到私钥计算

实战案例：RSA 加密破解（已知n和e）

七、处理 “字符串加密”：当关键信息被隐藏

1. 字符串加密的常见模式及破解

实战案例：破解自定义查表加密的字符串

八、混淆代码的逆向：拨开 “迷雾” 见逻辑

1. 常见混淆手段及识别

2. 去混淆技巧：从工具到手动梳理

工具去混淆

手动分析：以控制流平坦化为例

九、自动化逆向：用脚本提升效率

1. IDAPython：批量分析 IDA 中的数据

示例：用 IDAPython 批量提取所有字符串并保存

2. Angr：符号执行自动化破解

示例：用 Angr 破解校验函数

九、总结：逆向工程的 “道” 与 “术”

逆向工程是 CTF 中最考验综合能力的题型之一，其核心目标是 “看透” 程序的执行逻辑 —— 无论是找到硬编码的 flag，还是破解加密算法还原密钥，都需要结合静态分析与动态调试的技巧。本文将从工具使用、关键信息提取、算法逆向三个维度，手把手教你从 “黑盒” 程序中挖出核心线索，附实战案例与代码实现。

一、静态分析：用工具 “读” 懂程序的 “语言”

静态分析是指不运行程序，通过反编译工具直接解析二进制文件的结构、字符串、函数逻辑，快速定位关键信息。这一步是逆向的基础，也是最高效的 “捡分” 手段。

1. 静态分析工具：从入门到进阶

核心工具选型
工具 适用场景 优势
IDA Pro 复杂程序、加密算法分析 反编译精度高，支持插件扩展，字符串 / 交叉引用功能强大
Ghidra 开源免费，多平台支持 内置 decompiler，函数识别能力强，适合新手
Cutter 轻量逆向，快速浏览 基于 Radare2，界面简洁，支持动态调试集成
工具实战：用 IDA Pro 提取关键信息

以一个简单的 ELF 程序（secret）为例，演示静态分析步骤：

步骤 1：加载程序并初步浏览

  • 打开 IDA Pro，选择secret文件，默认设置加载（选择对应架构，如 x86-64）。
  • 等待分析完成后，进入主界面：左侧是函数列表（Functions window），中间是反编译窗口（Hex-Rays Decompiler，需付费版，免费版可用伪代码视图）。

步骤 2：字符串搜索 —— 快速定位敏感信息

  • 快捷键Shift+F12打开字符串窗口（Strings window），按 “Length” 排序（长字符串更可能是 flag 或密钥）。
  • 搜索关键词：flag、key、password、encrypt、secret。
    • 示例：若找到字符串flag{static_analysis_is_easy}，直接获取答案（此类 “送分题” 在 CTF 中常见）。
    • 若找到encrypt_with_key: 0x1234，则可能是加密密钥，记录备用。

步骤 3：函数交叉引用 —— 追踪关键逻辑

  • 若字符串是动态生成的（如flag={+ 变量 +}），需找到引用该字符串的函数：右键字符串→“Cross references to”（快捷键X），定位到调用该字符串的函数（如main或check_flag）。
  • 在反编译窗口分析函数逻辑，例如： 

    // IDA反编译的伪代码
int check_flag(char *input) {
    char key[] = "mysecretkey";
    char encrypted[32];
    encrypt(input, key, encrypted); // 加密输入
    return strcmp(encrypted, "xY3pL9qR2sT"); // 对比加密后结果
}

    由此可知：需找到encrypt函数的逻辑，逆向计算出与 “xY3pL9qR2sT” 匹配的输入（即 flag）。

2. 加密算法识别：从代码特征 “猜” 算法

静态分析的核心能力之一是通过代码特征识别加密算法，避免重复造轮子。以下是 CTF 中常见算法的识别技巧：

对称加密（AES、DES）
  • 特征 1：固定块大小：AES 块大小 16 字节（128 位），DES 为 8 字节，代码中可能出现0x10（16）、0x8（8）的常量。
  • 特征 2：轮函数：AES 有 10/12/14 轮（对应 128/192/256 位密钥），代码中会出现循环 10 次的轮操作，包含SubBytes（字节替换，常调用sbox数组）、ShiftRows（行移位）、MixColumns（列混合）。
  • 示例：若在代码中发现sbox数组（如0x63,0x7c,...），或函数名包含AES_encrypt，可确定为 AES。
非对称加密（RSA）
  • 特征 1：大素数运算：代码中出现大整数（如0xdeadbeef...超过 32 位）的乘法、模运算（%或mod函数）。
  • 特征 2：密钥对生成：存在p、q（两个大素数）、n=p*q、e（公钥指数，常见 65537）、d（私钥指数）的计算逻辑。
  • 示例：若发现pow(m, e, n)（明文 m 的 e 次方模 n），可确定为 RSA 加密。
哈希算法（MD5、SHA-1）
  • 特征 1：固定输出长度：MD5 输出 16 字节，SHA-1 输出 20 字节，代码中会有对结果长度的校验。
  • 特征 2：常量数组：MD5 有 4 个初始向量（A=0x67452301, B=0xefcdab89...），SHA-1 有 5 个（h0=0x67452301...），代码中会出现这些固定值。

二、动态调试：让程序 “说” 出中间结果

当静态分析无法完全还原逻辑（如加密算法复杂、存在动态生成的密钥）时，动态调试能帮我们 “实时观察” 程序的执行过程，获取内存中的中间值。

1. 调试工具：从 GDB 到 x64dbg

主流调试工具
  • GDB：Linux 下调试 ELF 程序的利器，配合pwndbg插件（增强显示栈、寄存器、汇编视图）更高效。
  • x64dbg：Windows 下替代 OllyDbg 的免费工具，支持图形化界面，适合新手调试 PE 程序。
GDB+pwndbg 实战：破解校验逻辑

以一个 “输入 flag 验证” 的程序（checker）为例，目标是找到正确输入（flag）。

步骤 1：准备工作

  • 安装 pwndbg：git clone https://github.com/pwndbg/pwndbg && cd pwndbg && ./setup.sh
  • 启动调试：gdb ./checker（进入 gdb 后自动加载 pwndbg）。

步骤 2：定位关键断点

  • 程序逻辑：输入字符串→加密→与目标值对比→输出 “正确” 或 “错误”。关键函数是strcmp（对比结果）和encrypt（加密过程）。
  • 设置断点： 

    break strcmp  # 在字符串对比处断下
break encrypt # 在加密函数处断下（若已知函数名）

步骤 3：运行程序并观察参数

  • 输入r运行程序，按提示输入测试值（如test），程序会在strcmp处暂停。
  • 查看strcmp的参数（两个对比的字符串）：

    bash

    x/s $rdi  # 第一个参数（加密后的输入）
x/s $rsi  # 第二个参数（目标值，即正确加密结果）

    假设输出：
    0x7fffffffde80: "xY3pL9qR2sT"（目标值）
    0x7fffffffde90: "aB1cD2eF3gH"（测试输入的加密结果）
    此时可知：需找到一个输入，其加密结果为xY3pL9qR2sT。

步骤 4：修改内存 / 寄存器，绕过校验

  • 若暂时无法破解加密，可直接修改对比结果让程序 “误以为” 输入正确：
    • strcmp返回 0 表示相等，因此修改返回值寄存器（如eax）为 0：

      bash

      set $eax=0  # 将返回值设为0（相等）
continue    # 继续运行，程序输出“正确”
    • 此方法适合快速验证 “输入正确是否能拿到 flag”，但需后续逆向算法获取真实 flag。
x64dbg 实战：追踪动态密钥

在 Windows 程序中，若密钥是动态生成的（如从内存中读取），可通过 x64dbg 追踪密钥的生成过程：

步骤 1：定位密钥使用位置

  • 假设程序调用CryptEncrypt（Windows 加密 API），在 x64dbg 中搜索该函数（Search for→Names in all modules），设置断点。
  • 运行程序，触发断点后，查看函数参数（通过栈传递）：hKey（密钥句柄）、pData（待加密数据）。

步骤 2：回溯密钥来源

  • 右键hKey→“Follow in Dump”（跟踪内存），查看密钥数据。
  • 若密钥在内存中动态生成，可通过 “回溯栈”（View→Call Stack）找到生成密钥的函数（如GenerateKey），在该函数内设置断点，重新运行即可获取密钥生成的完整逻辑。

三、算法破解：从输入输出推导加密逻辑

当程序对输入进行加密（如异或、自定义算法），且目标是 “找到使加密结果匹配已知值的输入” 时，需通过 “输入输出对比法” 推导算法，再用代码复现解密过程。

1. 异或加密：最常见的 “入门级” 算法

异或是 CTF 中最常见的加密方式，特征是 “加密解密同一算法”（c = m ^ k → m = c ^ k），且密钥通常固定。

实战案例：推导异或密钥
程序逻辑：输入m → 与密钥k异或 → 结果与c对比（c已知）。

步骤 1：获取已知的输入输出对

  • 用动态调试让程序加密两个不同的输入（如a和b），获取输出c1和c2：
    • 输入a（ASCII 0x61）→ 输出c1=0x35
    • 输入b（ASCII 0x62）→ 输出c2=0x34

步骤 2：计算密钥

  • 异或性质：k = m ^ c，因此：
    k = 0x61 ^ 0x35 = 0x54（验证：0x62 ^ 0x54 = 0x34，与c2一致，密钥正确）。

步骤 3：编写解密脚本
已知目标加密结果target = [0x3a, 0x2b, 0x1c]，用 Python 解密：

key = 0x54
target = [0x3a, 0x2b, 0x1c]
flag = ''.join([chr(c ^ key) for c in target])
print(f"flag: {flag}")  # 输出：flag{xyz}（假设结果）

2. 自定义算法：从 “黑盒测试” 到 “白盒还原”

当算法复杂（如多轮置换 + 混淆），需通过 “控制输入、观察输出” 的黑盒测试推导逻辑，再结合静态分析的代码片段验证。

实战案例：破解自定义分组加密
程序对输入分块处理（每 4 字节一组），目标是找到输入使输出为0x12345678。

步骤 1：测试单字节输入

  • 输入00 00 00 00 → 输出a1 b2 c3 d4
  • 输入01 00 00 00 → 输出a2 b2 c3 d4（仅第一字节变化）
  • 结论：第一字节的加密逻辑独立于其他字节。

步骤 2：推导单字节映射

  • 遍历输入00~ff，记录输出的第一字节，得到映射表f(x) = 输出（如f(00)=a1，f(01)=a2）。
  • 发现f(x) = x + 0xa1（简单加法），验证：00 + 0xa1 = a1，01 + 0xa1 = a2，正确。

步骤 3：扩展到多字节

  • 测试00 01 00 00 → 输出a1 b3 c3 d4，发现第二字节f(y) = y + 0xb2。
  • 最终推导算法：c[i] = m[i] + k[i]（k = [0xa1, 0xb2, 0xc3, 0xd4]）。

步骤 4：编写解密脚本
已知目标c = [0x12, 0x34, 0x56, 0x78]，解密：

k = [0xa1, 0xb2, 0xc3, 0xd4]
c = [0x12, 0x34, 0x56, 0x78]
m = [ (ci - ki) & 0xff for ci, ki in zip(c, k) ]  # 取模防止负数
print(f"明文：{bytes(m).hex()}")  # 输出解密后的输入

四、反调试与绕过：让程序 “允许” 被调试

部分程序会检测是否处于调试状态（如 CTF 中增加难度），需先识别反调试手段，再针对性绕过。

1. 常见反调试手段识别

  • ptrace 调用：Linux 程序通过ptrace(PTRACE_TRACEME, ...)检测调试（若已被调试，调用会失败），在 IDA 中搜索ptrace函数即可识别。
  • 进程状态检查：读取/proc/self/status中的TracerPid（非 0 表示被调试），代码中会出现对该文件的读取。
  • 时间差检测：通过rdtsc（CPU 时间戳）或sleep检测执行时间（调试时会变慢）。

2. 绕过技巧：从 Patch 到调试器设置

  • Patch 程序：用 IDA 找到反调试判断的条件跳转（如jne 0x401234，若调试则跳转至错误逻辑），将其改为无条件跳转（jmp 0x401234），保存修改后的程序。
  • 调试时跳过：在 GDB 中，当程序执行到反调试代码时，用set $pc = 0x401234（跳过当前指令）直接跳转。
  • 禁用 ptrace 检测：Linux 下启动程序时用setarch $(uname -m) -R ./program（禁用地址空间随机化 + 允许 ptrace 嵌套）。

五、实战总结：逆向解题的 “黄金流程”

  1. 静态优先：先用 IDA/Ghidra 搜字符串、找关键函数，尝试直接定位 flag 或算法逻辑。
  2. 动态辅助：静态卡壳时，用调试器跟踪关键函数（加密、对比），获取内存中的密钥、中间结果。
  3. 算法复现：通过输入输出对比推导算法，用 Python 复现解密逻辑，批量验证可能的 flag。
  4. 反调试绕过：若程序检测调试，先 patch 或跳过反调试代码，再进行调试。

逆向工程的核心是 “耐心 + 工具 + 逻辑推导”—— 即使面对复杂程序，只要拆解成小步骤，逐步分析，总能找到突破口。下一篇将聚焦 CTF 隐写术，带你挖掘文件中隐藏的秘密。

六、高级算法逆向：AES 与 RSA 的实战破解

在 CTF 中，除了基础的异或和自定义算法，AES（对称加密）和 RSA（非对称加密）是高频出现的 “中高级” 考点。这类算法逻辑固定但实现细节可能被修改（如密钥扩展、填充方式），逆向的核心是识别算法变体并提取关键参数（密钥、模数、指数）。

1. AES 加密的逆向：从 S 盒到密钥扩展

AES 算法的核心是 “轮操作”，包含 SubBytes（S 盒替换）、ShiftRows（行移位）、MixColumns（列混合）、AddRoundKey（轮密钥加）四大步骤。逆向时需重点关注：S 盒 / 逆 S 盒、轮密钥、填充方式。

实战案例：AES-ECB 模式破解（无填充）

某程序用 AES-ECB 加密 flag，已知密文c，通过逆向获取密钥key。

步骤 1：静态识别 AES 特征

  • 在 IDA 中搜索 “S 盒” 特征值（AES 的 S 盒是固定数组：0x63, 0x7C, 0x77, ..., 0x04），找到包含该数组的函数（即 AES 加密函数）。
  • 观察函数参数：通常包含input、key、output，其中key长度为 16 字节（AES-128）、24 字节（AES-192）或 32 字节（AES-256）。

步骤 2：提取密钥

  • 若密钥是硬编码的，直接在数据段查找 16/24/32 字节的连续数据（如0x2b, 0x7e, 0x15, ...），即为key。
  • 若密钥动态生成（如从文件读取），用 GDB 在加密函数处断点，查看key参数的内存地址： 

    # 在AES加密函数入口断点
b aes_encrypt
r
# 查看key地址（假设在rdi寄存器）
x/16xb $rdi  # 输出16字节密钥：0x2b,0x7e,0x15,...

步骤 3：编写解密脚本
已知key和c，用 Python 的pycryptodome库解密：

from Crypto.Cipher import AES
import binascii

key = binascii.unhexlify("2b7e151628aed2a6abf7158809cf4f3c8")  # 16字节密钥
ciphertext = binascii.unhexlify("3ad77bb40d7a3660a89ecaf32466ef97")  # 密文

# AES-ECB模式（无填充，因CTF中常省略填充）
cipher = AES.new(key, AES.MODE_ECB)
plaintext = cipher.decrypt(ciphertext)
print(f"解密结果：{plaintext.decode()}")  # 输出flag

2. RSA 加密的逆向：从大素数到私钥计算

RSA 的核心是 “大素数运算”，逆向的关键是提取n（模数）、e（公钥指数）、c（密文），并分解n得到p和q，最终计算私钥d。

实战案例：RSA 加密破解（已知n和e）

某程序用 RSA 加密 flag，已知n=0x...（大整数）、e=65537、c=0x...，求明文。

步骤 1：提取 RSA 参数

  • 静态分析：在 IDA 中搜索大整数（几百位十六进制数），通常n和e会硬编码在数据段（e多为 65537）。
  • 动态调试：若c是动态生成的（如输入 flag 后加密），在pow(m, e, n)处断点，查看c的内存值。

步骤 2：分解n获取p和q

  • 在线工具：用FactorDB查询n是否已被分解（CTF 中n多为小素数乘积，容易分解）。
  • 本地工具：用yafu（Yet Another Factorization Utility）分解：

    bash

    yafu "factor(0x123456789abcdef)"  # 替换为n的十六进制值

    输出：p=0x...，q=0x...

步骤 3：计算私钥d并解密

import gmpy2
from Crypto.Util.number import long_to_bytes

n = 0x123456789abcdef  # 模数
e = 65537  # 公钥指数
c = 0x987654321fedcba  # 密文
p = 0x12345  # 分解得到的素数p
q = 0x6789a  # 分解得到的素数q

phi = (p - 1) * (q - 1)
d = gmpy2.invert(e, phi)  # 计算e的逆元d
m = pow(c, d, n)  # 解密：m = c^d mod n
print(f"明文：{long_to_bytes(m).decode()}")  # 输出flag

七、处理 “字符串加密”：当关键信息被隐藏

CTF 中，开发者常对敏感字符串（如 flag、密钥）进行加密（如 XOR、Base64、自定义加密），静态搜索无法直接找到，需先逆向解密函数。

1. 字符串加密的常见模式及破解

加密方式 特征 破解思路
XOR 加密 存在^运算，密钥多为固定值或单字节 找解密函数，用已知明文（如 “flag {”）爆破密钥
Base64 加密 存在 64 字符表（ABCDEFG...+/），3→4 字节转换 识别编码表，用b64decode逆推
自定义查表 存在映射数组（如map[0]=0x66, map[1]=0x6c） 提取映射表，编写逆映射函数
实战案例：破解自定义查表加密的字符串

某程序将 flag 加密后存储，解密函数通过查表实现：decrypted[i] = table[encrypted[i]]。

步骤 1：定位解密函数

  • 静态分析：找到引用加密字符串的函数（如print_flag），发现其调用decrypt函数后输出结果。
  • 反编译decrypt函数，得到伪代码： 

    void decrypt(char *enc, char *dec) {
    char table[256] = {0x66, 0x6c, 0x61, 0x67, ...};  // 映射表
    for (int i=0; enc[i]!='\0'; i++) {
        dec[i] = table[(unsigned char)enc[i]];
    }
}

步骤 2：提取映射表并编写解密脚本

  • 从伪代码中提取table数组（共 256 字节）。
  • 构建逆映射表（inv_table[table[i]] = i），对加密字符串解密： 

    # 从程序中提取的加密字符串（十六进制）
enc_hex = "0102030405..."
enc = bytes.fromhex(enc_hex)

# 提取的映射表table（示例）
table = [0x66, 0x6c, 0x61, 0x67, 0x7b, ...]

# 构建逆映射表
inv_table = [0]*256
for i in range(256):
    inv_table[table[i]] = i

# 解密
decrypted = bytes([inv_table[c] for c in enc])
print(f"解密后的flag：{decrypted.decode()}")

八、混淆代码的逆向：拨开 “迷雾” 见逻辑

为增加逆向难度，CTF 题目常对代码进行混淆（如控制流平坦化、虚假分支、字符串加密），导致静态分析的伪代码混乱。此时需结合工具和手动分析简化逻辑。

1. 常见混淆手段及识别

  • 控制流平坦化：将线性逻辑拆分为多个基本块，通过跳转表（switch-case）跳转，伪代码中会出现大量case和goto。
  • 虚假分支：插入无意义的条件判断（如if (1 == 0) { ... }），实际不会执行。
  • 指令替换：用等价指令替换（如add eax, 1→inc eax），增加阅读难度。

2. 去混淆技巧：从工具到手动梳理

工具去混淆
  • Ghidra 去混淆插件：安装Decompiler Configuration插件，启用 “Flatten Control Flow” 选项，自动简化控制流平坦化代码。
  • IDA 插件：Hex-Rays Deobfuscator可去除简单的虚假分支和冗余指令。
手动分析：以控制流平坦化为例

步骤 1：识别主循环和跳转表

  • 混淆代码中通常有一个主循环（while (1)）和一个跳转表（case 0: ...; case 1: ...），每个case对应原逻辑的一个基本块。
  • 记录每个case的执行顺序（通过case末尾的next_case值），重建线性逻辑。

步骤 2：去除虚假分支

  • 对if (0) { ... }等恒假条件，直接忽略分支内代码；对if (1) { ... }，直接保留分支内代码。

示例：简化后的逻辑
原混淆代码（伪代码）：

int state = 0;
while (1) {
    switch(state) {
        case 0:
            a = 1;
            state = 1;
            break;
        case 1:
            if (0) { b = 2; }  // 虚假分支
            a += 2;
            state = 2;
            break;
        case 2:
            return a;  // 实际逻辑：a=1+2=3
    }
}

简化后：a = 1 + 2 = 3。

九、自动化逆向：用脚本提升效率

对于重复劳动（如批量提取字符串、爆破密钥），可编写脚本自动化处理，尤其适合 CTF 中的限时场景。

1. IDAPython：批量分析 IDA 中的数据

IDAPython 是 IDA 的脚本接口，可自动提取函数、字符串、交叉引用等信息。

示例：用 IDAPython 批量提取所有字符串并保存

import idautils
import idc

# 获取所有字符串
strings = idautils.Strings()

# 保存到文件
with open("extracted_strings.txt", "w") as f:
    for s in strings:
        # 过滤短字符串（长度<3）
        if s.length < 3:
            continue
        # 写入地址和字符串内容
        f.write(f"0x{s.ea:x}: {s.str}\n")

运行方式：IDA 中File→Script file...选择脚本，执行后生成extracted_strings.txt，快速筛选敏感信息。

2. Angr：符号执行自动化破解

Angr 是一款符号执行工具，可自动探索程序执行路径，适合破解需要输入特定值的题目（如校验函数返回1的输入）。

示例：用 Angr 破解校验函数

程序check(input)返回1当且仅当input是 flag，用 Angr 自动求解：

import angr

# 加载程序
proj = angr.Project("./checker", auto_load_libs=False)

# 定义输入状态（假设输入长度为32字节）
state = proj.factory.entry_state(
    stdin=angr.SimFileStream(name='stdin', content=angr.BVS('input', 32*8))  # 32字节符号变量
)

# 创建模拟器
simgr = proj.factory.simgr(state)

# 定义目标：找到使check函数返回1的路径
def is_successful(state):
    return state.regs.eax == 1  # 假设返回值存在eax中

# 开始探索
simgr.explore(find=is_successful)

# 输出结果
if simgr.found:
    solution = simgr.found[0].posix.dumps(0)  # 获取输入
    print(f"找到flag：{solution.decode()}")

适用场景：校验逻辑复杂（如多轮加密），手动逆向困难时，用符号执行自动爆破。

九、总结：逆向工程的 “道” 与 “术”

逆向工程的 “术” 是工具的使用（IDA/Ghidra 调试、脚本编写），“道” 是逻辑推导的能力 —— 从字符串到函数，从加密结果到算法逻辑，本质是 “拆解复杂系统，还原简单规则”。

在 CTF 中，逆向题的难度往往与 “信息隐藏深度” 正相关：

  • 简单题：flag 直接硬编码在字符串中，静态分析即可得解。
  • 中等题：flag 经简单加密（如 XOR、Base64），需逆向 1-2 层逻辑。
  • 难题：flag 经复杂算法（如 AES+RSA 混合加密）+ 代码混淆，需结合静态、动态、自动化工具逐层破解。

无论难度如何，耐心跟踪数据流向、善用工具验证猜想、用代码复现逻辑，都是破解逆向题的核心方法论。下一篇，我们将进入 CTF 隐写术的世界，探索图片、音频中隐藏的秘密。

# 网络 # 服务器 # 安全
Logo
广州城市开发者社区

欢迎加入我们的广州开发者社区，与优秀的开发者共同成长！

更多推荐

cover

web自动化测试，零基础入门到精通，收藏这篇就够了

avatar 广州城市开发者社区

一文读懂人工智能在供应链领域的典型应用

随着模型的训练，权重会发生变化，阴影部分的决策边界会逐渐环绕数据，学习到线性回归等更简单的模型无法捕捉到的非线性形状。我的正式头衔是“装袋员”，但我的职责远不止装袋。我们不会深入探讨其中的数学或工程原理，但即使只是对底层机制有一个大致的了解，也能帮助企业领导者做出更明智的决策，提出更精辟的问题，并确保人工智能得到负责任且有效的应用。人工智能可以根据产品的重要性、周转率或利润贡献对其进行分类，并自动

avatar 广州城市开发者社区

智能现金流预测与优化管理平台

现金流是企业生存和发展的命脉，准确的现金流预测和有效的现金流管理对于企业的健康运营至关重要。智能现金流预测与优化管理平台的目的在于利用先进的人工智能和数据分析技术，实现对企业现金流的精准预测和优化管理。本平台的范围涵盖了从现金流数据的收集、整理、分析到预测模型的建立、优化以及基于预测结果的现金流管理策略制定等多个环节。本文将按照以下结构进行阐述：首先介绍智能现金流预测与优化管理平台的背景信息，包括

avatar 广州城市开发者社区