留给小登的最后最后最后最后最后(真的是最后)一批题目
前言
有的时候就是会突然上头,多出一些题目啊…
今年Blockchain的原创题基本都是AI辅助出的:我给思路,Gemini/GPT给我方案,然后不断微调到自己想要(或者妥协后)的结果。相比于去年来说感觉不管是题目和Writeup好像AI味都重了不少,题目质量感觉也有所下降…我对自己大部分的题目质量都不是很满意
今年的Blockchain的大主题是DeFi安全,因此题目大部分和DeFi有关,之前本来想摆烂放弃出Layer2题目的想法的,但是由于手上Agent太好用,干脆烧点Token把这愿望给圆了得了,于是今年就有了2道跨链桥的题目+1道跨链桥背景的DevOps/DFIR题
当然,今年依旧是希望和去年一样紧跟时事(比如去年出了Prague的新Core EIP:EIP-7702),而且今年还是社团的建社十周年,所以本着温故而知新的想法,想着能不能从早期的题目里面找一些好玩的思路出来,顺带让我自己也学一点东西,最后也是成功翻到了一道很有意思的题目
总之还是希望这些题有一定意义吧,感觉不好的话尽管喷
正文
本Writeup中出现的所有信息(如地址、私钥等)请勿用于实际生产环境中!如有使用,后果自负!
STARTLINER
整个中秋假期都在写(chao)谱面的救赎感有没有懂的
但是音击的曲子质量真的好高啊…可惜只能在霓虹玩…
预期难度:1.3⭐
Docker镜像:未push到公共镜像仓库
考点:
- Ethereum合约基础交互
本题有2种获取flag的方法,其一是通关音游,前三首还好,但是第四首隐藏曲…
作为出题人,我的评价是:
再加上困难血条规则,你就玩吧,能过那flag给你也不算亏(毕竟你基本是中国4K最厉害的那一批玩家了)
所以我们还是走技术路线吧,更快而且更省力 (ˉ▽ˉ;)…
首先,我们需要知道flag在哪,这个在规则页面中有提到:
所以我们的flag在区块链上,那么如果我们想要和区块链进行交互,我们需要什么东西呢?
首先,我们需要知道区块链的RPC URL是什么,也就是提供区块链服务的网址是什么,这样我们才能和区块链交互
其次就是所谓的“合约地址”,前面的“合约”指代“智能合约”(Smart Contract),地址就是…地址…嗯…
你可以把合约理解为位于区块链上的程序,而每个程序都有属于自己的地址用于区分彼此
对于目前的状况,我们需要先找到网页是怎么获取flag的,如果是发送Web请求给后端就学着发送(当然这题不是Web题,所以是不可能的),如果是从区块链上获取的就找到上面的信息就行了
所以我们F12然后瞄一眼,发现所有的逻辑基本在两大坨Javascript里面,所以这里我给你们卜一卦:你们肯定不想看,所以你们肯定直接就扔给AI帮你分析了(笑)
但是实际上没必要那么复杂,你可以在代码里面先搜索关键词,这样通常能大幅缩小你的查找范围(AI帮你改代码的时候也经常是以搜索关键词的方法进行过滤的),这里你可以用flag或者是rpc,这里以后者为例,一共应该有28个匹配项,其中大部分都是一些Error,也就是和RPC相关的错误,但是看到最后一个眼睛瞬间亮了:
1 | async function Fm() { |
这里面有刚刚提到的RPC URL,有合约地址(那个contractAddress),有函数名getFlag和需要传入的参数(那个args,实际上就是不需要传入任何东西,直接调用getFlag()就行),不过RPC URL还是不明确,只知道它和这个e有关,而这个e又是调用了jm('/api/chain')这个函数得到的结果
对于一部分同学应该会下意识去访问http://靶场链接/api/chain,然后就能找到RPC URL了,不过我们这里严谨一点,看看jm这个函数是长什么样的:
1 | async function jm(e, t) { |
实际上就是通过fetch调用传入的路由路径,返回的是r,也就是n.json()(第12行),所以访问得到的结果应该是一个JSON格式的东西,所以我们尝试访问一下这个路由(这里请把图中展示的localhost:32768换成你自己的靶机链接😊):
为了方便各位看,我稍微用工(chu)具(zi)美化了一下:
1 | { |
可以看到还有两个我们没提到的,一个是用于区分不同区块链的chainId,一个是合约的应用二进制接口abi,你就简单理解为菜单吧,你没法点菜单上没有的菜,然后菜单会告诉你这道菜用了什么东西做的,大概就是这个意思,具体的定义你们自己查,就当课后习题了(
所以我们就可以尝试自己获取flag了,这里用一个叫Web3py的Python库进行操作:
1 | from web3 import Web3 |
对于希望进阶一点的同学,下面是留给你们的课后习题,自己通过AI或者搜索引擎了解为什么可以这样调用函数:
1 | from web3 import Web3 |
Fruit Market
这题质量比我出的大部分题目都高(笑)
预期难度:3.0⭐
Docker镜像:ccr.ccs.tencentyun.com/cauliweak9/gpn26-fruitmarket-buffed:v2.1
考点:
- 三明治攻击(Sandwich Attack)
本题为德国比赛GPN CTF 2026的同名原题,并非本人原创题(引用的链接已失效,估计是服务器关了)
查看题目源码,我们可以看到这题每2~10秒会生成一个交易,且每个交易都有一个过期时间戳,如果出现3个交易没能及时Approve,那么靶机就会直接死掉
除此之外,整个AMM遵循的是Uniswap V2的那个经典乘积固定公式:$X\times Y=k$
我们的目标是通过一开始给的10 APL不断套利赚取500 APL,而想实现套利最经典的方法就是三明治攻击(Sandwich Attack)
详细的说明可以看看Cyfrin的文章:Solodit Checklist Explained: Sandwich Attacks,这里就只做简述:
除去一开始的观察部分,三明治攻击实际上分为抢跑(Front-running)和尾随(Back-running)两部分,攻击者在正常的交易前后各进行一次交易,把正常的交易像三明治一样夹在中间,这就是名字的由来
假如正常的用户M要用A换取B,那么M的交易最终会导致A的价格降低、B的价格增高(因为A多了,B少了),而攻击者X借助这一点,在M的交易之前抢先执行自己的交易X1,使用A换取B,这样抢先以正常价格囤积B,之后M的交易正常执行,但是由于A贬值了,所以M最后换取的B实际上变少了,但是交易的结果仍旧是让B增值,因此最后X只需要执行第二个交易X2把高价值的B全部拿去换取A即可从中获利,整个过程中只有M是受害者,需要承担损失
正常情况下攻击者往往要查看Pending Transactions来确认交易并抬高Gas费保证X1能在M之前执行,但是这道题很贴心地给了你自主控制交易顺序的权限,因此会自由很多,但是由于有效期的限制,因此最佳方案还是写脚本实现攻击,题目也给了socketio的样例代码
下面这个脚本我忘记能不能跑了,应该是能过的,总之不会的各位自己让AI帮忙吧(
1 | import requests |
NEM Shenzhen
预期难度:2.2⭐/3.5⭐/4.6⭐
Docker镜像:正式镜像未push到公共镜像仓库
考点:
- 简单NFT开发
- Solidity Bytecode Jail
- delegatecall
- EIP-7702
Flag 1
这一部分实际上就是开发题,功能也比较简单,现在又是大AI时代,一般来说AI都能秒杀,这里就不再展开了
Flag 2
字节码长度检测脚本只检测我们传入的地址的字节码,因此我们可以这样想:有没有一种情况,能让某个合约在字节码极少的情况下仍旧能保留完整的功能呢?
这里一般的同学会陷入一个误区:合约的功能必须由当前合约实现,但是在智能合约里面,某个合约的功能是可以由其他合约提供的,而对应的关键点就是delegatecall操作码和代理合约
因此我们的思路就转变为了:
- 创建一个功能完整的NFT合约,其能通过flag1的检测
- 创建另一个代理合约,其implementation指向的是完整功能的NFT合约
这样,我们所有发送到代理合约的请求都会通过delegatecall代理到NFT合约,不过delegatecall相关技术细节这里就不展开了
简单搜索一下代理合约,可以了解到EIP-1167,它规定了Minimal Proxy Contract,即最小代理合约,其只有45个字节码长度,因此可以很轻松通过flag2的检测,我们完成部署后提交代理合约的地址就能拿到flag2了
AI还是太好用了
1 | import os |
Flag 3
Flag3的检测要求合约字节码只有30bytes,而单单是存放一个地址就要20bytes,就算不使用Flag2的代理合约思想,强硬去构造功能,那么光是选择函数并返回就够喝一壶的了
所以最后还是只能回到Flag2的思路,只是这次我们需要去了解是否存在Ethereum的特性能满足这一点的:又能实现代理,代理合约的字节码又很短
搜索过程可能会有一点点麻烦,不过应该还是能搜到的,这里直接讲考点吧(感觉和Misc的某些题一样,没见过的话就不好做)
实际上这题考察的就是EIP-7702的特性:EIP-7702除去能让EOA地址执行合约逻辑,同时会更改EOA地址的字节码,以表示该地址使用的是哪个合约的逻辑,格式也非常简单:
1 | 0xef0100(20-byte address) |
可以看到只有23个字节的长度,因此就很简单了,让AI写一个脚本就行
1 | import os |
ASTERISM Protocol
本题灵感来源于出题人身边的一个真实案例,
以及出题人吃过的一坨办的连路边的野狗都不会去看一眼的陈年大粪比赛
预期难度:3.3⭐
Docker镜像:ccr.ccs.tencentyun.com/cauliweak9/asterismprotocol:v1.1
考点:
- Github取证
- 敏感数据泄露
本题使用的地址私钥均为随机生成的私钥,请不要将题目内出现的所有私钥、签名等用于实际生产环境中,以免出现资产损失
各位做这道题的时候应该能发现它和其它区块链题目不一样,题目不给附件,而源码又是放到Github上的(在靶机里面给了链接),但是最后又要和靶机交互…总之是非常神秘的一道题
不过首先让我们看看合约都有哪些吧:
1. 信息收集
src里面只有3个合约:
AuroraToken:基础的ERC20合约AuroraMultisig:一个简单的2/3多签钱包AuroraVaultV1:一个Initializable,Ownable和UUPSUpgradeable的Vault合约,其中的VAULT_STORAGE_LOCATION实际上是实现了ERC-7201的规范,为了在一定程度上预防升级合约后可能出现的Storage Collision问题
与此同时,根据靶机内给出的Deploy.s.sol部署脚本我们可以知道:
题目部署的时候会读取环境变量中的
PRIVATE_KEY和SIG_0~3一共4个变量的值题目还部署了一个ERC1967Proxy代理合约,其实现为部署好的AuroraVaultV1,后面我们交互的对象是那个Proxy合约
在给代理合约初始化的时候将多签钱包
AuroraMultisig设置为了owner初始铸造了1000 AuroraToken(ATK)并在最后直接调用
AuroraToken.transfer给了Vault
最后根据多签钱包的实现和Github repo的Readme可以知道:
- 三个签名分别为3个不同的帐户对
MULTISIG_WALLET_OWNER_[ChainId]的签名 - 三个签名对应的三个地址和Readme中提到的三个地址是一致的
- 如果想要使用多签钱包执行交易,需要让其中一个钱包所有者先提交交易,然后需要至少2个所有者通过该交易后方可执行交易
合约这边基本就分析完了,好消息是功能不多,坏消息是因为功能不多,所以并没有漏洞(至少出题人没找到ヽ( ̄ω ̄( ̄ω ̄〃)ゝ)
那么问题来了,如果这道题没有漏洞,那岂不是无解吗?
2. 漏洞挖掘
此时我们可以看看Akari同学的Github Profile:
可以看到Akari同学实际上提交了2次commit,但是Github里面无论怎么找都只能找到1个commit,另一个commit就好像失踪了一样
不过让我们看一下项目的文件…里面好像有个文件叫….env?
众所周知,.env通常用于存放项目中可能会使用到的环境变量,而这题里面环境变量除了三个签名还有个PRIVATE_KEY,而这种东西理论上是不应该被传上去的,很容易出现敏感数据泄露
因此我们在这里不得不考虑可能有这种情况发生:Akari同学在第一次commit的时候不小心把PRIVATE_KEY给明文扔上去了,但是很快意识到了,于是她把库删了然后往同名的repo重新提交了一次commit,这样看起来就像是“第一次提交”一样
那么在这里我们实际上有至少2种途径可以解决这道题:
- 爆破:虽然我们无法正常看到这次commit,但是如果我们知道commit的哈希,我们仍旧能访问到对应的commit记录(前提是Github没有定时清理走),而Github支持的哈希最短只需要4个字符,因此我们的爆破范围只需要从
0000~ffff就可以了,新生赛一般打一周,访问65536次Github API应该还好,但是注意别搞得太过火被Github ban了(笑) - 查看其它人的Fork:如果有人在Akari同学还没来得及删库的时候Fork了原来的repo,那么Forked repo就会原样保留原来的那一次repo
这两种方法各位都可以尝试一下,因为这题实际上非常巧,它的哈希前缀很小,不需要爆破太多次就能找到,而且这个repo刚好有一个Fork,因此我们这里以第2种方法为例完成这道题目
我们在repo主页找到Insights栏,点开后选择Forks,注意在Repository type中同时选中Inactive类型,因为这个Fork可能之后就没有更多的push活动了,最后应该能看到下面的结果:
我们可以看到,是一位Chinatsu同学Fork了这个repo,此时我们去查看这个Forked repo:
可以看到.env里面赫然就是被无意中泄露的私钥PRIVATE_KEY,最后能确认其对应的地址就是三个Owner之一的Akari-Aurora,也就是Akari同学自己的私钥
不仅如此,在Readme里面提供了签名的使用样例,里面同样使用了私钥pk,而我们查看后会发现Readme里的私钥和.env中的不一样,且这个新的私钥能对应上Yuzu-Aurora的地址
因此通过这个简单的Github Forensics,我们成功获取到了2个Owner地址的所有权,那么根据2/3多签的规则,我们实际上就已经能完全控制整个多签钱包乃至于整个系统了
接下来的事就很简单了:部署恶意合约,然后往多签钱包提交一个upgradeToAndCall的交易并通过2次,最后执行交易将Proxy的实现从AuroraVaultV1更改为我们的恶意合约,同时执行合约的提款函数,卷走所有的ATK
3. 参考Exp
参考的恶意合约AttackVault.sol如下:
1 | // SPDX-License-Identifier: MIT |
参考的攻击脚本attack.py如下:
1 | from web3 import Web3 |
Ethereum History
感觉理论上应该是今年的签到题啊,但是被Legacy Transaction狠狠拦住了
实际上是出题人实在不敢塞套娃但是又特别想塞套娃因此折中塞了个闯关
预期难度:3.4⭐(综合)
Docker镜像:ccr.ccs.tencentyun.com/cauliweak9/ethereumhistory:v1.1
考点:
- 略(每一关都有写)
太多小问了,让AI帮我写wp了,如果Mermaid代码块没法渲染的话各位自行找办法吧
Level 1 - Pre-Byzantium: The Constructor Typo
目标
Setup 部署 AuroraVault,并向其中存入 10 ETH。通关条件是:
1 | address(target).balance == 0 |
也就是说,真正目标不是修改某个布尔变量,而是清空 AuroraVault 的余额。
观察影响因素
AuroraVault.withdraw() 会把全部余额转给 owner,但要求:
1 | require(msg.sender == owner); |
所以问题变成:能不能成为 owner。
继续看初始化逻辑,合约里有一个函数:
1 | function AuroraVauIt() public { |
早期 Solidity 构造函数必须和合约名完全一致。合约名是 AuroraVault,而这里是 AuroraVauIt,最后一个看起来像 l 的字符实际是大写 I。因此它不是构造函数,而是一个部署后仍可公开调用的普通函数。
推导触发方式
既然 AuroraVauIt() 是普通 public 函数,那么任意人都可以调用它,把 owner 改成自己。随后再调用 withdraw(),权限检查就会通过。
攻击链路
1 | flowchart LR |
最终链路很短:读取目标 Vault 地址,调用拼写错误的“构造函数”夺取所有权,再调用 withdraw() 清空余额。
Level 2 - Homestead: The DAO Reentrancy
目标
Setup 向 TheDAO 存入 10 ETH,通关条件是:
1 | address(target).balance == 0 |
目标仍然是清空目标合约余额。
观察影响因素
TheDAO.withdraw() 的关键顺序是:
1 | uint amount = balances[msg.sender]; |
它先读取余额,然后外部转账,最后才把余额清零。这里有两个关键影响因素:
call.value(amount)()会把执行权交给msg.sender。balances[msg.sender] = 0在外部调用之后才执行。
因此,在攻击合约收到 ETH 的 fallback 里,原来的余额还没有被清零。
推导触发方式
如果攻击合约先存入一笔较小金额,例如 0.5 ETH,它的 balances[attacker] 就是 0.5 ETH。第一次调用 withdraw() 时,DAO 给攻击合约转 0.5 ETH。在 fallback 中再次调用 withdraw(),此时 DAO 还没执行到清零语句,所以仍然认为攻击合约有 0.5 ETH 可以提款。
这个过程可以重复,直到 DAO 余额不足或达到设置的重入次数上限。
攻击链路
1 | sequenceDiagram |
最终链路:部署攻击合约,存入启动资金,调用 withdraw(),在 fallback 中循环重入,最后把攻击合约收到的 ETH 转回攻击者。
Level 3 - Byzantium: STATICCALL
目标
本关有两个核心合约:TokenVault 和 RewardPool。Setup 给 RewardPool 注入 10 ETH,并向 TokenVault 存入 0.1 ETH。通关条件是:
1 | address(pool).balance == 0 |
也就是清空奖励池。
观察影响因素
RewardPool.claimReward() 根据两个只读信息发奖:
1 | uint myShares = vault.balances(msg.sender); |
getVirtualPrice() 又依赖:
1 | (totalSupply * 1 ether) / address(this).balance |
因此奖励金额受三个值影响:
- 攻击者在 Vault 中的份额
balances[msg.sender]。 - Vault 的
totalSupply。 - Vault 当前 ETH 余额。
TokenVault.withdraw() 使用了 nonReentrant,看起来阻止了重入提款。但它的状态更新顺序仍然是:
1 | require(msg.sender.call.value(amount)()); |
这意味着在转账回调期间,Vault 的 ETH 余额已经下降,但 balances 和 totalSupply 还没有更新。
推导触发方式
我们不能在 fallback 里再次调用 vault.withdraw(),因为有重入锁。但可以调用另一个合约 RewardPool.claimReward()。
claimReward() 只是读取 Vault 状态,不修改 Vault,所以它不会被 Vault 的重入锁拦住。更关键的是,Byzantium 之后只读调用逐渐被 STATICCALL 语义支撑,但“只读”不代表“读到的一定是稳定状态”。
攻击者可以:
- 先向 Vault 存入较大份额。
- 调用
withdraw()。 - 在收款 fallback 中,Vault 的 ETH 余额已经减少,但份额还未清零。
- 此时调用
RewardPool.claimReward(),奖励池看到的是被放大的getVirtualPrice()。
攻击链路
1 | sequenceDiagram |
最终链路:利用提款过程中的短暂不一致状态,让奖励池通过只读接口读取到被操纵的价格,从而清空奖励池。
Level 4 - Constantinople: EXTCODEHASH
目标
Setup 给 Bank 注入 10 ETH,通关条件是:
1 | address(bank).balance == 0 && (!bank.isEOA(bank.claimer())) |
不仅要取走钱,还要求最终记录的 claimer 不是 EOA。
观察影响因素
Bank.flashAirdrop() 只允许 isEOA(msg.sender) 为真:
1 | require(isEOA(msg.sender), "Only EOA allowed"); |
而 isEOA() 使用 EXTCODEHASH 判断调用者是否没有代码:
1 | extcodehash(_addr) == keccak256("") |
直觉上,合约地址应该有代码,所以不能通过。但 EVM 中合约构造期间有一个特殊阶段:地址已经存在,构造函数正在执行,但 runtime code 尚未写入账户。
因此,在构造函数里对外发起调用时,外部合约观察 msg.sender,会看到这个地址还没有 runtime code。
推导触发方式
只要在攻击合约的 constructor 中调用 bank.flashAirdrop(),Bank 就会用 EXTCODEHASH 检查正在构造的攻击合约地址。此时攻击合约地址没有 runtime code,检查会误判为 EOA。
交易结束后,攻击合约部署完成,runtime code 存在。Setup.isSolved() 再检查 !bank.isEOA(bank.claimer()),此时 claimer 已经是一个有代码的合约地址,第二个条件也满足。
攻击链路
1 | flowchart TD |
最终链路:利用 constructor 阶段的代码空窗,绕过基于 EXTCODEHASH 的 EOA 检查。
Level 5 - Petersburg: CREATE2
目标
Setup 部署一个安全模板 Template,记录其 runtime code hash,然后部署 AirdropRegistry 并注入 10 ETH。通关条件是:
1 | address(registry).balance == 0 |
Registry.claim() 只有在 isApproved[msg.sender] 为真时才付款。
观察影响因素
Registry.approve() 的信任依据是调用者当前的代码哈希:
1 | extcodehash(caller()) == SAFE_HASH |
如果某个地址当前的 runtime code 和 Template 一致,它就能被批准。批准结果存储在:
1 | isApproved[msg.sender] = true; |
注意,批准绑定的是地址,不是代码。只要地址被批准,后续 claim() 不再重新检查代码哈希。
这就引出两个问题:
- 能否让某个地址先拥有
Template代码,通过approve()。 - 随后能否让同一个地址变成恶意代码,再调用
claim()。
在 Cancun 之前,SELFDESTRUCT 可以删除合约代码;而 CREATE2 可以用相同 salt 和相同 init code 重新部署到同一个地址。0age metamorphic pattern 正是利用固定 init code 从工厂读取 implementation,把不同 implementation 的 runtime code 部署到同一个 CREATE2 地址。
推导触发方式
第一世部署为 Template 代码:
- 通过 metamorphic factory 和固定 salt 计算出一个固定地址。
- 让该地址的 runtime code 来自链上原版
Template。 - 调用
approveRegistry(registry),Registry 看到调用者代码哈希等于SAFE_HASH,于是批准该地址。 - 调用
Template.kill(),在旧语义下删除该地址代码。
第二世部署为攻击代码:
- 使用同一个 factory 和 salt 再次部署,地址保持不变。
- 这次 implementation 换成
Attack。 - 因为
isApproved[同一地址]仍然为真,直接调用claim()领取 10 ETH。
攻击链路
1 | flowchart TD |
最终链路:把 Registry 的“当前代码哈希检查”与地址级批准状态拆开,利用 CREATE2 + SELFDESTRUCT 让同一地址前后呈现两种不同代码。
Level 6 - Istanbul: Repriced SLOAD
目标
Setup 给 IstanbulGate 注入 10 ETH,通关条件是:
1 | address(gate).balance == 0 |
要调用 claim() 取走 Gate 里的钱。
观察影响因素
IstanbulGate 有两个阶段。
enroll() 使用完整 gas 调用攻击者的 isBanned():
1 | (bool ok, bytes memory data) = msg.sender.staticcall(...); |
这要求攻击合约在完整 gas 下返回 true。
claim() 则用固定 700 gas 再次调用同一个接口:
1 | msg.sender.staticcall.gas(700)(isBanned()) |
然后计算:
1 | bool stillBanned = ok && data.length == 32 && abi.decode(data, (bool)); |
也就是说,领取阶段不是要求返回 false,而是要求“没有成功得到 true”。如果低 gas 调用失败,ok == false,stillBanned 就是 false。
关键点是 Istanbul 的 EIP-1884 提高了 SLOAD 成本。一个包含 SLOAD 的 isBanned() 在完整 gas 下能正常返回,但在 700 gas 下会因为 gas 不足失败。
推导触发方式
攻击合约让 isBanned() 从 storage 读取一个布尔值并返回。这样:
enroll()完整 gas 调用时,SLOAD成功,返回 true,登记成功。claim()的 700 gas 调用时,SLOAD成本过高,调用失败。- Gate 将失败解释为
stillBanned == false,允许领取。
攻击链路
1 | sequenceDiagram |
最终链路:让同一个查询在完整 gas 和旧式低 gas 预算下表现不同,利用 Gate 对低 gas 失败的宽松解释完成领取。
Level 7 - Berlin: Warm Storage
目标
Setup 给 BerlinGate 注入 10 ETH,通关条件是:
1 | address(gate).balance == 0 |
需要让 BerlinGate.unlock() 成功。
观察影响因素
BerlinGate.unlock() 用固定 2300 gas 调用 Archive.read():
1 | address(archive).staticcall{gas: 2300}(read()) |
要求调用成功并返回预期的 bytes32。
Berlin 的 EIP-2929 引入 cold/warm access。第一次访问某个账户或 storage slot 是冷访问,成本更高;同一笔交易内再次访问则变为 warm,成本下降。
所以 Archive.read() 在 2300 gas 下能否成功,不只取决于 read() 函数本身,还取决于这笔交易里此前有没有访问过 Archive 的存储槽。
推导触发方式
如果直接调用 unlock(),它内部第一次读 Archive.sealedWord 是冷访问,2300 gas 不够,调用失败。
但如果在同一笔交易中,先主动调用一次 Archive.read(),这个存储槽会被预热。随后再调用 BerlinGate.unlock(),内部的 2300 gas 读取变成 warm SLOAD,成本下降,可以成功返回。
攻击链路
1 | flowchart LR |
最终链路:在同一笔交易内先 warm storage,再让目标合约执行固定 gas 的读取。
Level 8 - London: Base Fee Market
目标
Setup 给 BasefeeVault 注入 10 ETH,通关条件是:
1 | address(vault).balance == 0 |
需要满足 claim() 中的 basefee 条件。
观察影响因素
BasefeeVault.quote() 记录调用者当时的 block.basefee:
1 | quotedBasefee[msg.sender] = block.basefee; |
claim() 要求:
1 | block.basefee > quotedBasefee[msg.sender] |
也就是说,影响通关的是“当前区块 basefee 是否高于报价区块 basefee”。
London 的 EIP-1559 中,basefee 会根据上一个区块 gas 使用情况调整。如果某个区块 gas 使用量高于目标值,下一个区块的 basefee 会升高。
推导触发方式
要让 claim() 通过,需要先低价 quote,再让后续区块 basefee 上升。攻击合约的 quoteAndBurn() 做两件事:
- 调用
vault.quote(),记录当前 basefee。 - 在同一笔交易里循环消耗大量 gas,让该区块接近满块。
这笔交易被打包后,下一个区块的 basefee 会根据高 gas 使用量上调。随后调用 claim(),block.basefee 就可能大于之前记录的报价。
攻击链路
1 | sequenceDiagram |
最终链路:利用 EIP-1559 basefee 会被上一块 gas 使用量影响这一事实,把“费用信号”变成可推动的状态条件。
Level 9 - Paris: PREVRANDAO
目标
Setup 给 RandaoJackpot 注入 10 ETH,通关条件是:
1 | address(jackpot).balance == 0 |
需要提交正确的彩票 ticket。
观察影响因素
RandaoJackpot.claim(ticket) 要求调用者是合约:
1 | require(msg.sender.code.length > 0); |
然后计算:
1 | ticketFor(msg.sender) |
其公式是:
1 | keccak256(abi.encodePacked(block.prevrandao, player, address(this))) |
因此 ticket 受三个值影响:
- 当前区块的
block.prevrandao。 - 调用者地址。
- Jackpot 合约地址。
看起来 prevrandao 是链上熵源,但在同一笔交易中,攻击合约也能读取完全相同的 block.prevrandao。
推导触发方式
攻击合约本身满足 msg.sender.code.length > 0。在 attack() 内部,它读取当前交易上下文中的 block.prevrandao,用自己的地址和 Jackpot 地址计算 ticket,然后立刻调用 jackpot.claim(ticket)。
因为计算和验证发生在同一笔交易、同一个区块上下文中,双方看到的 prevrandao 完全一致。
攻击链路
1 | flowchart LR |
最终链路:不要把公开区块字段当成调用者无法同步使用的随机数;攻击合约可以在同一交易里计算并提交正确答案。
Level 10 - Cancun: SELFDESTRUCT
目标
Setup 给 SelfdestructMuseum 注入 10 ETH,通关条件是:
1 | address(museum).balance == 0 |
但 Museum 的 claim() 需要先完成两个观察:
- 旧合约执行
SELFDESTRUCT后代码仍然存在。 - 同交易中新建并销毁的合约可以变为空代码地址。
观察影响因素
Cancun 的 EIP-6780 改变了 SELFDESTRUCT 语义。对于已经存在的合约,selfdestruct 不再删除代码;但在同一笔交易中创建并销毁的合约,仍然会在交易结束后没有代码。
SelfdestructMuseum.breakOldRule() 调用已有 Relic.vanish(),然后检查:
1 | address(relic).code.length > 0 |
这在 Cancun 后成立。
另一个条件来自:
1 | constructorPing() |
它要求:
1 | msg.sender.code.length == 0 |
这可以由正在构造的合约调用,因为 constructor 执行期间 runtime code 尚未写入。
随后 recordConstructorDeath(target) 要求这个 target 被记录为构造期出现过,并且当前代码长度为 0。
推导触发方式
攻击合约先调用 breakOldRule(),记录 Cancun 后旧合约 selfdestruct 不清代码。
然后在同一笔攻击交易中部署一个临时合约 Ephemeral。它的 constructor 做两件事:
- 调用
museum.constructorPing(),利用构造期code.length == 0被记录。 - 立刻
selfdestruct(receiver)。
因为 Ephemeral 是同一交易中新建并销毁的合约,部署表达式返回后,它对应地址没有 runtime code。攻击合约拿到这个地址,调用 recordConstructorDeath(empty),最后 claim(empty)。
攻击链路
1 | flowchart TD |
最终链路:同一题中同时展示 EIP-6780 的“旧合约不删代码”和“构造期新合约仍可消失”的例外。
Level 11 - Prague: EOA Set Code
目标
Setup 给 EOAAirdrop 注入 10 ETH,通关条件是:
1 | address(airdrop).balance == 0 |
EOAAirdrop 每次 claim() 只发 1 ETH,所以要重复领取十次。
观察影响因素
注册阶段限制:
1 | require(msg.sender.code.length == 0, "EOA only"); |
领取阶段:
1 | require(registered[msg.sender]); |
影响因素有两个:
- 注册时必须是无代码账户。
- 领取时先外部转账,之后才设置
claimed[msg.sender] = true。
传统情况下,EOA 收款不会执行回调,所以开发者可能觉得这没有重入风险。但 Prague / EIP-7702 允许 EOA 在交易中携带代码执行,使“注册时是 EOA”和“领取时能执行回调”同时成立。
推导触发方式
先用普通 EOA 调用 register(),此时 EOA 没有代码,通过注册。
然后部署一个账户实现合约 Level11Account,其中:
attack(setup)读取 Airdrop 地址并调用claim()。receive()在收到 1 ETH 时,如果 Airdrop 余额还够,就再次调用claim()。
最后发送一笔 EIP-7702 set-code 交易,让同一个已注册 EOA 临时委托到这个实现合约,并把交易 to 设置为该 EOA 自己、data 设置为 attack(setup)。
此时从 Airdrop 看,msg.sender 仍然是已经注册过的 EOA 地址;但这次 EOA 已经能执行 Level11Account 的代码。第一次 claim() 转账进入 EOA,触发 receive 逻辑,在 claimed[msg.sender] 尚未设置为 true 前继续重入。重复直到 Airdrop 余额被取空。
攻击链路
1 | sequenceDiagram |
最终链路:利用 EIP-7702 让同一个地址在注册时满足 EOA 假设,在领取时具备合约回调能力,从而把“给 EOA 转账无需防重入”的旧直觉打破。
总结
这 11 关可以按安全假设的演进理解:
| 关卡 | 时代 / EIP | 被打破的假设 |
|---|---|---|
| Level 1 | 早期 Solidity 构造函数 | 函数名像构造函数就只会执行一次 |
| Level 2 | The DAO 时代 | 外部转账后再更新状态也安全 |
| Level 3 | Byzantium / STATICCALL | 只读调用读到的状态一定可靠 |
| Level 4 | Constantinople / EXTCODEHASH | 没有代码就一定是 EOA |
| Level 5 | CREATE2 + 旧 SELFDESTRUCT | 地址和代码身份可以永久绑定 |
| Level 6 | Istanbul / EIP-1884 | 固定 gas 探测在升级后仍稳定 |
| Level 7 | Berlin / EIP-2929 | 固定 gas 读取不受交易内访问历史影响 |
| Level 8 | London / EIP-1559 | block.basefee 是不可推动的环境值 |
| Level 9 | Paris / EIP-4399 | prevrandao 可直接当作调用者未知随机数 |
| Level 10 | Cancun / EIP-6780 | SELFDESTRUCT 总会删除代码 |
| Level 11 | Prague / EIP-7702 | EOA 永远不会执行回调逻辑 |
整体脉络是:早期漏洞更多来自语言和合约写法,随后逐渐转向 EVM opcode、gas 规则、区块字段、账户模型和生命周期语义。真正需要训练的不是记住某个漏洞名字,而是看到一条安全判断时,追问它依赖的底层语义在哪个历史版本里成立、在哪个硬分叉后已经改变。
AuroraSFS
最史的一道题目,允许出题人双亲起飞
预期难度:5.0⭐
Docker镜像:ccr.ccs.tencentyun.com/cauliweak9/aurorasfs:v1.1
考点:
- 整型溢出
- 边缘情况处理不当
- EIP-7939:
CLZOpcode
老样子,还是先看看合约都有哪些吧
1. 初始信息收集
AuroraToken:简单的ERC20AuroraLoan:利润率0.1%的闪电贷AuroraAMM:基础的AMM,类似Uniswap V2,但是多了一个multicall功能AuroraSFS:核心合约,实现了一个通过位图保存Sequencer的SFS合约
以防各位还是没看懂SFS到底是怎么样的,这里再解释一下:
简单来说就是开发者可以往SFS合约注册自己的合约,这样每当有交易涉及到自己的合约时,开发者都能从Layer 2的手续费中获取一小部分作为激励
本题对SFS的实现进行了概念的抽象化(因为我懒得真的搓一个Layer 2,调试好麻烦 ……]((o_ _)’彡☆):当玩家的合约使用AMM进行代币的兑换时,会收取手续费,而如果玩家的合约注册了SFS,手续费就会以双倍返利的形式返还给玩家
2. 漏洞挖掘
2.1 AuroraAMM.multicall
仔细看一下AMM的代码,发现它在实现multicall的时候缺少一个非常重要的条件检验:哪些人能调用multicall
更加糟糕的是,这里的multicall是真的会用合约自己的余额进行交易的,也就是说AMM的资金可以直接通过multicall发送给任意地址
2.2 AuroraSFS.registerGoldenContract
但是这还不足以满足题目要求,因此我们此时转向SFS,可以看到如果我们如果想要提走SFS的所有资金,我们需要:
- 让
isWithdrawPaused变为false - 让我们自己对应的
_tokenId名下有超出SFS余额的资金
其中后者是相对比较容易达成的,因为我们可以看到processSequencerFee是只接收来自AMM的调用的,而且会将earned[tokenId]加上msg.value的两倍,因此我们可以通过multicall调用这个函数,把AMM的资金全部转给SFS,这样我们应该就有能卷走2倍AMM资金的权力了
那么难点在于isWithdrawPaused这个点,我们可以看到我们要么通过Storage Collision成为admin,要么通过Storage Collision写入isWithdrawPaused,总之让我们看一下唯一一个高度嫌疑的函数registerGoldenContract吧
可以看到合约维护了一个长度为256的地址数组,同时使用了一个位图用于记录有多少个地址已经注册了Sequencer,主要逻辑都在内联汇编里面,那让我们拆解一下吧:
1 | // 让我们假定bitmap=0x3=0b000...0011 |
虽然看起来过于冗余和麻烦,但是整体逻辑看起来非常正常,可是让我们看看CLZ的规范文档里面的摘要是怎么写的:
1 | Introduce a new opcode, CLZ(x), which pops x from the stack and pushes the number of leading zero bits in x to the stack. If x is zero, pushes 256. |
如果传入的x为0,则返回256,这看起来十分合理,毕竟前置0有256个,但是正是这种边缘情况导致本题发生了漏洞
我们可以想象,如果isolated为0,那么clz(isolated)就是256,而freeSlot就应该是255-256
需要注意的是,在Solidity的内联汇编中,是不会进行整型溢出检查的,因此freeSlot发生了下溢,变成了2**256-1
接下来,targetSlot又加了1,所以又出现了上溢,最后targetSlot的结果就是0
换句话说,此时覆盖的就是admin地址,也正是这题的突破口
那么倒推回来,x&-x保留的是最低位的1,但是如果x本身就是0呢?那返回的就是0自己,而让inverted为0的话,bitmap就应该是2**256-1,而这也意味着此时goldenContract已经注册满了,即注册了256个goldenContract
虽然注册需要上交10 ether的注册费,而我们又没那么多钱,但是我们可以在闪电贷中途完成此次攻击,而攻击需要调用registerGoldenContract一共257次,因此我们至少需要通过processSequencerFee传入2570 ether才能覆盖SFS所有的资金
3. 攻击线路构建
所以我们的思路就非常简单了:
- 首先借取闪电贷
- 其次部署256个dummy注册
goldenContract - 使用攻击合约进行注册,覆盖
admin - 攻击合约调用
togglePause开启提款通道 - 通过
multicall调用processSequencerFee,在将AMM的资金全部转移进SFS顺带拉高提款额度 - 调用
withdraw提走SFS内的所有资金 - 归还闪电贷,完成攻击
不过由于gasLimit的存在,同一次交易内根本无法实现这完整的攻击,最终gas会耗尽导致revert,其中的大头就是部署256个dummy合约,因此我们可以先部署好合约,然后需要进行攻击的时候往dummy转账10 ether,触发其receive函数,让它们自己去注册goldenContract,这样就把合约部署和攻击调用拆分开来了
4. 参考Exp
因此最后这里给出一个参考用的web3py脚本(主要是部署256次合约真麻烦吧)
1 | import time |
いちげき!
(さん にっ)
![]()
预期难度:4.7⭐
Docker镜像:ccr.ccs.tencentyun.com/cauliweak9/aurora-bridge:v1.1
考点:
- 跨链桥安全——消息传递与校验
- 初始化配置错误
引言
跨链桥听起来很高级,而且项目代码看起来也十分复杂,但是实际上整个跨链桥可以抽象为3部分:链A上的资产合约、链B上的资产合约,以及在两条链之间传递数据的relayer(中继服务)和验证消息真伪性与合法性的validator(消息验证者)
如果抽象成了上面的逻辑,那么我们实际上就可以将对跨链桥的审计拆解为2条链上的普通的合约审计+1个消息传递安全性的审计,而这其中最容易出现问题的部分就是relayer,毕竟验证消息来源、格式等是否合法需要考虑的东西是非常多的,而考虑的越多越复杂就越容易出现纰漏(你可能会算错积分,但是1+1你总不会算错吧www)
因此对于一个跨链桥,我们会更加倾向于去审计跨链消息的传递是否存在安全问题,比如比较经典的因为没有判断链ID而导致的重放攻击(Replay Attack),跨链信息验证存在缺陷导致的证明操纵(Proof Manipulation),甚至用于监听跨链事件的验证者(Validator)也有可能存在解析问题导致出现问题,当然还有经典的私钥窃取啥的,这里就不过多展开了
正文
虽然题目描述已经给出了题目设计原型,但是我们还是用一点古法的分析尝试解决这道题吧
首先看题目要求,就是提走AuroraVault中所有的wAUR,而想让Vault吐出所有的wAUR只有release()函数这一个办法,而它又只能由AuroraRouter触发,Router又只有一个handleMessage()能触发,但是它又指向AuroraReplica,最后能触发这个函数的只有process()了,所以我们就知道应该要构造一个Message然后触发process(),使得目标达成
process()函数乍看起来确实没有什么太大问题,messageId不仅包含了基本上所有的信息,而且后面的比对也是十分正常的:查看当前信息的Merkle根是否被接受了(如果要接受Merkle根首先需要调用prove()),同时检测消息是否被复用了,通过检测才会进行操作
但是我们可以看到检测Merkle根是否被接受的依据是confirmedAt这个时间戳,而它也会在migrate()和submitUpdate()这两个函数中被赋值。虽然admin和updater都被权限保护了,我们也无法获取权限,但是或许在跨链协议初始化的时候,协议配置可能会留下什么线索(想想你们Web各种CMS写在源码里的默认账密,类比一下是一样的)
不仅如此,别忘了Solidity里面未赋值本质上和0x0基本等价,因此如果我们伪造了一条信息,那么messages[messageId]的值为0x0的概率几乎为1(你真运气好给你碰上哈希碰撞了算你厉害),最后进行检测的Merkle根哈希就是0x0,那么是否有那么一种可能,协议在初始化的时候调用了migrate(0)或者submitUpdate(0)呢?
这个时候我们就需要去看protocol-config.json了,整体应该还算好懂,就算不去看解析配置的Python源码应该也能大致猜出来,配置里面包含的是协议包含的所有智能合约、它们所在的链、创建合约时需要调用的值、以及初始化时额外需要进行的交易操作,因此最后我们会在transactions里面找到下面这段内容:
1 | { |
可以看到协议初始化的时候真的调用了migrate(0),因此这就是本题的漏洞所在:因配置问题导致的任意消息伪造,即使消息未通过prove()验证也可以通过检验并执行操作
所以最简单的方法就是直接往Layer 2的AuroraReplica调用process()就行,至于参数怎么填你可以先发送一个正常的跨链请求然后自己看,或者啃源码也不是不行,这里我也懒得写解题脚本了,反正你们直接复制粘贴我的思路给AI它也能给你们吐出来
仔细想想,好像跨链桥审计也没想象那么难,对吧 ✌( ̄ー ̄)
全彩高清(?):
![]()
Nexus Stellaris: Flumina Stellaria(Blockchain方向)
Akari同学创建跨链桥的初衷(确信)
![]()
是的,Akari指代的就是Hoshizaki Akari(星咲明里),那么ASTERISM是在指代什么呢,好难猜啊ο(=•ω<=)ρ⌒☆
预期难度:4.5⭐
Docker镜像:ccr.ccs.tencentyun.com/cauliweak9/aurora-bridge:v2.1
考点:
- 跨链桥安全——消息传递与校验
引言
如果你搞懂了上一道题,那么这一道题实际上会更加简单(5⭐虚高诈称说是),如果觉得代码很长看不懂可以尝试diff一下两道题的分支,当然我相信大部分同学如果直接使用网页的Compare会出现下面的情况:
不过如果你有稍微读过图中的超链接的话,应该可以知道实际上这里的Compare是用的默认的Three-dot比较,而只需要使用Two-dot比较就能实现我们想要的结果(当然你拉到本地自己把两个分叉merge了我也没意见)
正文
我们可以看到Ver.2这次没有忘记提交Merkle证明了,而且是relayer自动帮你提交,之前的配置错误也删掉了(所以理论上你也可以先做这一题然后diff一下推测前一题存在什么问题),不过框架和逻辑大体没什么改动,就是这个process()有个问题…
仔细看看新版(绿色)第87行,它在计算消息的哈希的时候居然没有包含最为关键的消息体body?!而且直接就拿着这个哈希就上去比较了?那换句话说,这个body岂不是任人摆布,可以随意伪造?
所以这题反倒更简单,首先发送一个正常的跨链交易,把自己所有的AUR发送到Layer 2(为了达成hasPlayerDeposit()目标),此时我们已经获得了自己的经过Merkle证明的messageId,当然我们也知道了除去body以外的所有参数应该填入什么(以伪造一个“合法”的消息),所以最后一步就是伪造body然后调用process()就可以美美下班了
Akari同学知道这些后be like:
![]()
我超,有铸币
Nexus Stellaris: Ventus Stellaris(Forensics方向)
Team ASTERISM外出放松的花絮放送(确信)
![]()
预期难度:5.1⭐
Docker镜像:ccr.ccs.tencentyun.com/cauliweak9/aurora-bridge-devops:v1.1
考点:
- 日志审计
- 后门查杀
- (反正就是应急响应那堆东西)
其实靶机里面还有运维相关的问题,但是因为数据在MySQL里,和Misc那边的SQLite的考点有一定重叠,所以没拉出来
Q1
1 | 请阅读Web服务的相关日志,确认攻击发生的时间。 |
一般来说,对于一个Web服务,如果它受到了类似RCE那样的攻击,那攻击者使用的HTTP方法大概率是POST方法,当然也有其它情况,具体情况还得根据实际情况判断
日志通常情况下被放置在/var/log中,题目背景中的“消息”也有提示说带aurora字样的都属于跨链服务,所以我们ls后看到的/var/log/aurora就是跨链服务留下来的日志了
1 | ops@0c5a095c12f3:~$ sudo ls -al /var/log/aurora |
我们可以看到这里的日志里面有一个操作审计日志ops-audit.jsonl,我们读取一下:
1 | ops@0c5a095c12f3:~$ sudo cat /var/log/aurora/ops-audit.jsonl |
可以看到用户aurora-web执行了4次任务,虽然根据名字我们可以判断这个用户大概率是用于运行Web服务的专用用户,不过还是十分可疑,所以我们继续看Web服务的日志web.jsonl
1 | ops@0c5a095c12f3:~$ sudo cat /var/log/aurora/web.jsonl |
这就很可疑了,首先就是这些任务执行的时间都比较长,甚至有1.2秒的任务,其次就是正常人为什么会向检测连接性的路由发送POST请求呢?
不过由于连接性那个路由返回了403 Forbidden,而且操作审计日志里面只有后者,因此我们选取第一个往诊断路由发送POST的时间,注意答案只精确到秒
1 | 答案:2026-08-15T02:13:04Z |
请注意:现实场景中出现403之类的错误码并不一定代表你的攻击失败了
Q2
1 | 请根据日志中的信息,阅读Web服务源码,确认攻击者利用的OWASP漏洞种类(以2025年的榜单为准)以及Web服务源码中对应出现问题的变量名。 |
此处我们使用ps命令查看正在运行的进程,毕竟题目背景中提到只有“外部服务”被关闭,因此服务大概率还在运行,当然我们也可以顺带查看一下是否有比较可疑的进程,毕竟背景和题目都在暗示存在可疑的进程
1 | ops@0c5a095c12f3:~$ ps -aufx |
我们可以看到Web服务是Python运行的,不过我们不知道aurora_web这个目录在哪,因此我们可以使用find命令查看一下:
1 | ops@1454265b622a:~$ find / -name "aurora_web" 2>/dev/null |
所以我们确认了这个aurora_web的目录所在,接下来就是翻一下目录
1 | ops@1454265b622a:~$ sudo ls /opt/aurora/web/aurora_web/ |
接下来我们读取一下app.py就可以了,不过由于前面我们知道发生攻击的路由位于/api/v1/ops/diagnostics,因此我们可以用grep查找指定关键词并查看上下文:(这里的-C 6指的是以关键词所在行为中心,显示其上下6行的结果)
1 | ops@1454265b622a:~$ sudo cat /opt/aurora/web/aurora_web/app.py | grep "diagnostics" -C 6 |
根据之前得到的信息,我们只需要看diagnostics_probe(),而里面的command插入了两个值,一个timeout一个endpoints[endpoint],后者进行了一定的验证操作,但是timeout这个变量没有经过任何过滤和处理就直接插入了将要执行的命令中,因此我们可以知道Web服务存在的问题是命令注入(Command Injection),而它在OWASP Top 10:2025中被归类在A05 Injection中,而且出现问题的变量我们也锁定了,那么这题答案也呼之欲出了
1 | 答案:A05:2025_timeout |
Q3
1 | 请对机器进行排查,并确认攻击者使用了何种MITRE ATT&CK子技巧实现了持久化。 |
还记得上面ps命令查看的进程吗?其实有一个进程十分可疑:
1 | aurora-+ 889 0.0 0.5 52700 42204 ? Ss 23:03 0:00 \_ systemd-timesyncd -m timesyncd |
systemd全称System Daemon,即系统守护进程,虽然systemd-timesyncd这个进程服务确实真实存在,但是首先运行它的用户是aurora-+(这里的加号是因为长度被截断了),大概率是aurora-web,不过无所谓,我们可以用getent group查看所有的用户和它们所属的用户组,这里由于长度原因不做展示
接下来让我们看看systemd-timesyncd - ArchWiki是怎么说的:
1 | To make use of this daemon a new system user and group "systemd-timesync" needs to be created on installation of systemd. |
没看到这个systemd-timesync用户组吧,说明这个服务就不应该能运行,但是嘛…
除此之外,根据Linux中timesyncd.c这个源码:
1 | if (argc != 1) |
这个程序不应该被传入任何参数,但是从ps看它就是有参数,说明这个进程十有八九有问题,而且不觉得这个-m的用法很像Python运行模块的命令吗?
一般的,系统守护进程服务的文件被放置在/etc/systemd/system/下,我们查看一下这里的文件:
1 | ops@c43436495da2:~$ sudo ls -al /etc/systemd/system |
让我们看看这个恶意的服务是怎么写的:
1 | ops@c43436495da2:~$ sudo cat /etc/systemd/system/systemd-timesyncd.service |
可以看到只要启用了系统守护进程(systemctl enable),那么只要启动就会自动运行这个服务,且这个服务被关闭后5秒内会自动重启,这就是攻击者进行的持久化操作:伪造一个systemd进程实现持久化
最后我们只需要在MITRE ATT&CK Matrix里面查看Persistance中对应的子技术就可以了
1 | 答案:T1543.002 |
Q4
1 | 请锁定攻击者部署的持久化程序的绝对路径。 |
从上面伪造的Systemd Service文件我们可以看到ExecStart指向的是/usr/lib/systemd/systemd-timesyncd,换句话说就是这个系统服务启动会运行这个文件,让我们看一下这个程序(此处省略cat命令):
1 | #!/usr/bin/env python3 |
现在我们可以确认这个就是持久化程序了
1 | 答案:/usr/lib/systemd/systemd-timesyncd |
注:这里使用了一种叫命令行参数隐藏的技巧,所以你在
ps中看到的进程命令行没有python
Q5
1 | 请分析持久化程序,尝试获取并分析其释放的二阶段Payload,确认攻击者在Payload中使用的64字节以太坊地址私钥。 |
为了让大家节省一下时间,这里会用一个相对简单快速的方法解决这个问题
我们可以看到这个程序进行了一系列操作,具体在干什么你可以不用管,你只需要看到最后这几行:
1 | stage = decode_dynamic_bytes(encoded) |
本质上就是获取Payload代码、写入Payload并执行,而我们可以删掉后面的执行操作,只让它写入Payload就可以了,不过最好修改一下STAGE_PATH所在的目录,比如到/tmp这种任何用户都有权限写入的位置,以防出现权限错误
你可能会发现靶机里面没有vi之类的编辑程序,但是我们可以在自己的电脑上写完代码再通过scp发送文件,当然它也可以接收文件,而且你只要有ssh就会有scp,所以不用担心还要去下载什么软件
这里需要你在自己的电脑中使用scp,这里给出两个例子:
1 | PS H:\> scp -P 32800 ops@localhost:/usr/lib/systemd/systemd-timesyncd . |
前者是从靶机中获取systemd-timesyncd并发送到自己的电脑中,后者则是把自己电脑中的systemd-timesyncd发送到靶机的/tmp/目录下,-P是指定端口
完成传输后记得chmod +x开启执行权限然后执行代码,最后从STAGE_PATH里面获取二阶段Payload就可以了,如果觉得cat不方便你也可以用scp发送回自己的电脑用编辑器查看,这里就不展开Payload的代码了,自己尝试一下吧,私钥应该在代码的开头部分
1 | 答案:0x7c852118294e51e653712a81e05800f419141751be58f605c371e15141b007a6 |
Q6
1 | 请分析二阶段Payload,并确认攻击者窃取的敏感文件的绝对路径以及攻击者接收该文件使用的URL。 |
简单看一下Payload,可以看到这个程序从某些地方获取了一些数据,经过解密后得到需要执行的命令并执行,最后将结果加密后发送了出去
那么依旧和Q5同理,我们可以自行修改一下代码,让脚本自己解密,同时将结果保留下来,这里给各位说一下应该修改什么
- 在
process_once中,command完成赋值后可以添加一行写入文件的操作(如Path("/tmp/commands.txt").write_text(json.dumps(command), encoding="utf-8")) - 删除
main()中的绝大部分代码,只保留读取配置和执行的操作 - **修改
STATE_DIR**,否则会出现权限冲突导致执行失败
这里不过多展开修改后的代码,总之执行后的结果如下:
1 | ops@1454265b622a:~$ sudo cat /tmp/commands.txt |
于是最后我们就能很清晰地看到攻击者窃取的敏感文件和接收它时使用的URL是什么了
1 | 答案:/run/aurora/secrets/relayer.key_http://203.0.113.47/collect |
后记
如各位所见,本题Writeup中的Q5和Q6使用了修改代码的方法获取Payload,这样写wp主要有两个原因:
一是因为出题人希望能从一个“弱区块链基础”的视角去完成这道题目,毕竟再怎么说这是一道运维题,即使它的背景是区块链,即使攻击者利用了区块链实现攻击。当然,这一题实际上也只是冰山一角,甚至有很多地方都是不够真实的,也欢迎各位狠狠锐评一下这道题目,锐评的话记得和出题人说一声,出题人务必火速赶来捧场
二是出题人希望各位能意识到一个点:虽然Misc中有各种各样的隐写,但是无论你藏的再怎么逆天,只要你想利用里面隐藏的数据,最后就一定需要将其提取出来,而提取这一步是最容易被检测到的。我完全可以不知道你怎么藏的,我只需要利用你已有的提取程序就能拿到我想要的东西,就像这题一样,你可以不知道EtherHiding这个技术,你只需要会读Python,会写文件,你就能拿到Payload
当然,这也是为什么出题人现在十分“厌恶”Misc的隐写题,因为出题人认为它对现实的意义和价值不大,当然每个人有自己的看法,出题人对此表示尊重且愿意以平等友善的态度讨论交流彼此的看法喵
量子力学のためのDeFiシステム
最后还是因为知识匮乏只能出一个类Uniswap V2的MEV
预期难度:6.9⭐
Docker镜像:ccr.ccs.tencentyun.com/cauliweak9/qtm_defi_hack:v1.0
考点:
- 预言机操控(Oracle Manipulation)
- 只读重入(Read-only Reentrancy)
非线性整数除法规划问题
1. 初始信息收集
首先,让我们看一下各个合约的功能以及它们的用途吧:
QuantumToken(QTM):一个常见的ERC20合约,但是添加了一个send函数,使得合约使用send进行转账的时候会像ERC777那样触发目标合约的tokensReceived函数MeteorLoan:一个ETH闪电贷合约,手续费1%NovaSwap:一个AMM流动性池,池中两种代币分别是ETH和QTM,添加流动性返还Nova LP作为奖励,除此之外还有着价格预言机的作用PulsarVault:一个借贷金库,允许用户抵押Nova LP借出金库里的ETH和QTMSetup:实例初始化合约
根据Setup,我们可以得到如下的初始状态:
| 持有Token\合约 | MeteorLoan | NovaSwap | PulsarVault | Setup | 玩家 |
|---|---|---|---|---|---|
| ETH | 1000 ether | 10 ether | 100 ether | 0 | 10 ether |
| QTM | 0 | 10 ether | 100 ether | 0 | 0 |
| Nova LP | 0 | 0 (minted 10 ether) | 0 | 10 ether | 0 |
题目的目标有两个:
- 清空
PulsarVault中的所有ETH和QTM - 玩家余额 > 80 ether
也就是说我们要尽可能从攻击中获利
2. 漏洞挖掘
让我们逆着推一下:如果要清空Vault,唯一的路径就是borrow,而borrow则需要我们通过depositLP往里面抵押Nova LP,我们能借贷的额度则强依赖于Swap的价格预言机getLPPrice,最终能借贷的总额度是:
$$
Stake_{LP} * Price_{LP} * 0.8 = Borrow_{ETH} + Borrow_{QTM}
$$
由此我们的目标则可以转移为“尽可能提高Nova LP的价格”,所以我们进而查看getLPPrice:
1 | function getLPPrice() external view returns (uint256) { |
这个预言机的公式逻辑是这样的:
$$
Price_{LP} = \frac{ETH * QTM}{LP^2} * 1 \space ether
$$
因此我们有三种途径抬高Nova LP的价格:
- 添加ETH
- 添加QTM
- 减少LP
让我们暂时放到一边,转头看看其它的函数,可以发现关键的函数基本都被添加了nonReentrant修饰符,不过有一个函数比较有意思:
1 | function removeLiquidity(uint256 lpAmount) external nonReentrant { |
我们可以看到在移除流动性的时候,会先销毁LP,因此LP应该是无法操控的了,然后会触发qtm.send进行QTM的转账,最后发送ETH
还记得前面信息收集的时候写的吗?使用send进行转账会触发目标合约的tokensReceived函数,而此时对于当前池子的情况,我们可以发现:
- LP已经正常减少
- QTM已经正常减少
- ETH还没有发生变化
而我们从预言机的公式可以发现,此时LP的价格应该是异常升高的,由此我们可以知道最后面的攻击路径:
实际上这一部分进行的就是Oracle Manipulation(预言机操纵)攻击,其攻击使用的方法则是Read-Only Reentrancy(只读重入),我们可以发现被重入的函数是一个view的只读函数,而被攻击的合约/函数通常是强依赖于这个view函数的某个合约/函数,而合约内一大把的nonReentrant对此完全没有任何限制作用
3. 攻击线路构建
我们已经找到了关键漏洞点,所以我们继续往前推:
3.1 获取Nova LP
为了触发removeLiquidity,我们首先得先往里面addLiquidity,但是添加流动性需要我们有QTM往里面转账,否则无法通过(因为合约会认为你有故意调高QTM的价格然后通过swap砸盘的嫌疑),而添加的ETH:QTM比例最多不得超过Swap池中的ETH:QTM比例
总的来说,就是我们需要先通过swapETHforQTM兑换出一些QTM,然后再添加流动性获取Nova LP
而我们初始拥有的那可怜的10 ETH(没那么多,部署合约和交易还要gas)没法获取足额的Nova LP,同时也无法拉大LP的价格,因此这里我们就需要用到闪电贷合约MeteorLoan了
闪电贷合约初始有1000 ETH,远大于Swap初始的10 ETH池子,因此我们可以对QTM进行做市,并获取大量的Nova LP
3.2 撕裂预言机
现在我们已经有了LP,而borrow的前提是要我们先存入LP作为抵押资产再进行借贷,因此假定我们有着90%的LP(剩下10%是Setup在进行初始化后持有的),也就是说我们有90LP,那么我们可以将一部分(比如40LP)存入金库作为抵押,然后销毁其余的50LP以使用第2部分的线路触发漏洞
但是在实际测试过程中,我们发现单单这一次的价格撕裂无法一次性借空Vault里的所有资产
上面的例子中,计算得到的预言机单价为2,因此抵押物总资产为80 ether,无法达成100 ether + 100 ether的总额
因此我们需要对getLPPrice进行更进一步的操控,而通过swap或者流动性操纵都无法进行过大的价格波动,不过对于价格操作那个我们有另一个方法:捐赠攻击(Donation Attack)
攻击的原理很简单:我们可以通过外部转账的方式控制Swap的流动性池子,进而对预言机进行更进一步的操纵
前面已经提出了3种方案,目前的分析来看操控LP是不可行的,而ETH由于不存在receive或者fallback函数,因此也不可行,唯一的途径就是使用QTM进行价格操纵了
但是我们自己持有的QTM不够,因此我们可以先通过borrow借走少量的QTM,然后将部分QTM“捐赠”给Swap以抬高LP的价格,最后再一次利用同样的路径触发攻击以借走所有的资产
3.3 收尾
别忘了我们还在闪电贷过程中,而由于手续费的存在,我们需要还1010ETH,因此最后我们需要通过swapQTMforETH将手上持有的QTM全部砸给Swap,最后套现离场
这也说明捐赠的时候要尽可能少捐赠QTM,不然我们大概率无法使得自己的余额超过80 ETH
4. 攻击链路框架
经过了上面的分析,我们的攻击步骤框架如下:
- 进行闪电贷:向
MeteorLoan借取1000ETH - 获取做市资金:消耗部分ETH在
NovaSwap兑换QTM - 垄断流动性:将换得的QTM和绝大部分ETH全部注入
NovaSwap的池中,铸造大量Nova LP - 设置抵押物:将部分Nova LP存入
PulsarVault用于抵押 - 触发漏洞:将剩余的Nova LP通过
removeLiquidity进行销毁,此时NovaSwap会发送对应价值的QTM给我们,并触发我们的tokensReceived钩子- **[钩子内部 - Stage 1]**:此时ETH暂时没有退还,因此LP价格偏高,可以先根据已有的抵押物价格,借走适量的QTM
- **[钩子内部 - Stage 2]**:将目前持有的QTM“捐赠”给
NovaSwap,使得LP价格进一步暴涨,进而提升抵押物的价格 - **[内部 - Stage 3]**:进行第二次的借款,借走
PulsarVault中剩余的所有资产
- 离场:结束钩子,让
NovaSwap完成剩余的ETH转账 - 套现与还款:此时我们手上有着大量QTM,将所有QTM通过
swapQTMforETH换成ETH进行套现,最后还款完成闪电贷,此时我们手上应该还会有盈余
5. 套利规划与求解
线路有了,但是选择太多了:选多少ETH兑换QTM,选多少Nova LP进行抵押,第一次borrow借走多少QTM,等等等等,此时我们可以尝试将其转化为一个规划求解问题
但是这里我们有一个的问题:Swap的池子满足的公式是$XY=k$,因此在Swap的时候,我们需要规划的是$\frac{XY}{X+Y}$这个非线性整数除法问题,如果使用Z3求解会陷入路径爆炸
既然我们已经确认了攻击的完整路径以及途径的所有函数,那么我们可以使用网格搜索,然后求出完整路径上每一步的最优数值参数就可以了
虽然有很多选择,但是这里我们可以约束到4个核心参数:
- 初始换取QTM时所用的ETH数量
- 作为抵押物的LP占比
- 第一次借出的QTM数量
- 捐赠的QTM数量
接下来你可以让AI写一个脚本去模拟完整的路径下各合约代币的变化,以及是否能够正确执行(因为中途可能发生余额不足、整型溢出等问题),然后编写自动化脚本去模拟结果并获取一个相对最优解,下面给一个我让AI写的样例:
1 | import time |
需要注意的是,由于Solidity没有浮点数,因此模拟的时候请务必使用整型和整除以忽略小数点,从而做到最佳模拟结果
以上面提供的样例脚本为例,最后我这边求解得到的结果是这样的:
1 | 🚀 启动自动化漏洞规划求解器 (Auto-Exploit Planner)... |
不过按照这个参数进行攻击,最后发现还是会触发Insufficient collateral的错误,因此稍微调高了一点点捐赠的QTM(8.2 ether)
6. 完整攻击流程图与参考Exp
本题攻击完整的流程图如下图所示:
下面是本题的参考Exploit合约:
1 | // SPDX-License-Identifier: MIT |
ASTE/RISK: For 10th Aurora
Sol Do Re Mi Fa Mi Re Do
预期难度:8.0 (ε+3)⭐
Docker镜像:ccr.ccs.tencentyun.com/cauliweak9/asterisk:v1.1
考点:
- EVM JOP
本题灵感来自于2018年的RealWorldCTF Finals的赛题
Acoraida Monica,题目详情可以参考出题人于DEFCON27做的Presentation(defcon27/README.md at master · xhyumiracle/defcon27),本题没那么难
题目合约非常朴实无华,一个Setup合约检测Vault的钱是否都被转走了,一个SimpleVault合约只有基础的存取款功能,没有unchecked块,没有整型溢出,功能也一切正常,一切看起来完全…不可解
那让我们换个思路:我们看到的合约再怎么样也只是一个ABI,一个接口,一层皮,而我们真正交互的是部署在链上的Runtime Bytecode,而这个是不会变的(至少在Cancun之后是不会变了),因此我们可以尝试往字节码层面下手
1. 字节码的比对
我们可以使用eth_getCode把vault的字节码拉下来,同时我们有着原来的合约,因此我们可以把两个字节码对比一下:
字节码出现了不一致的情况!如果只是最后不一样那无伤大雅,因为那一部分是我们的Metadata Hash,具体一点是我们的IPFS Hash,因此不用过于担心,但是中间的核心逻辑出现了不一致的情况…说明题目描述给的合约大概率和实际情况有所出入…
我们可以看到一共有3个地方出现了不一致的地方,虽然Metadata Hash目前看起来不一定有问题,但是我们发现标志性的ipfs字符串不见了,因此最好留个心眼先
2. 反编译逻辑
接下来就是中间的核心逻辑里面出现了偏差,此时让我们查看对应的反编译逻辑,好消息是中间夹着一堆00(STOP),应该会非常好找
如果用Dedaub反编译的话,不管是看反编译后的Solidity还是Yul都看不到实际的逻辑,在这题里面说句实话EtherVM用起来会更舒服一点
1 | label_014C: |
别被那么多字节码吓到,实际上0x018C的LT就是在进行小于的比较,也就是在进行if (userBalances[msg.sender] < amount)的比较,然后我们可以发现如果不满足条件会往栈里面推一个0回去,然后紧跟着的ISZERO就会把0吞掉换一个1回去,因此JUMPI就会被触发,跳转到0x01C3的部分,由此我们可以确认问题出在userBalances[msg.sender] < amount的时候,也就是revert的逻辑被改了
仔细看看0x0192开始的部分,这里给出简单的解析:
1 | bytes memory trampoline = abi.encodePacked( |
就是这一部分往内存0x20~0x40写入了一个1,而往0x00~0x20写入了msg.sender,最后进行keccak256(msg.sender,1)
如果各位还记得存储排布相关的知识的话,应该能想起来官方文档里面写的这样一句话:
1 | The value corresponding to a mapping key k is located at keccak256(h(k) . p) where . is concatenation and h is a function that is applied to the key depending on its type: |
所以这一部分代码绝大部分都是在获取userBalance[msg.sender]
但是SLOAD后直接使用取到的值当JUMP的参数跳转了…等等,实际上整个程序长度肯定远不及我们有的余额(1 ether=1e18),因此我们可以通过控制userBalance来控制跳转的PC地址,换句话说就是任意跳转!
如果你找到了这个漏洞,那么在此欢迎你来到EVM JOP(Jump-Oriented Programming)的世界
简单了解的话可以读一下CTF Wiki:Jump Oriented Programming - CTF Wiki
3. 触发JOP
EVM中的JUMP以及JUMPI指令最后跳转的指令必须是一个JUMPDEST指令,即0x5B,因此我们可以查找一下所有的指令,最后应该能找到71个
虽然人工看71个JUMPDEST是可行的,不过我们发现有那么一个非常特殊:它正好是前面我们提到的Metadata Hash的开头,而由于Metadata Hash实际上并不会影响程序的正常运行,因此我们可以尝试看看这一部分的反编译代码:
1 | 04A1 5B JUMPDEST |
欸,我们看到在0x04B7的DELEGATECALL之前往栈里面塞了好多东西,让我们看看实际上会用到什么吧:
除此之外还有个CALLDATALOAD,看看它又会用到什么吧:
因此它会读取你的calldata,并从偏移0x24处取32字节压入栈里
按照顺序来看,应该是这样:
gas:GASaddress:CALLDATALOAD[0x24]argsOffset:0x1CargsSize:0x04retOffset:0retSize:0
而在此之前又将0x9890220B放在了内存的0x00~0x20处,非零有效位刚好是从0x1C开始的4字节,因此我们可以确认这个0x9890啥的是一个函数选择器
与此同时,0x24=36=4+32,放在calldata的语境下刚好是一个函数选择器+一个参数的长度,考虑到前面我们有个withdraw(uint256)进行任意跳转,因此合理推测这就是正确的攻击路径,而我们需要在调用withdraw的时候再往calldata后面加上一个恶意合约的地址用于delegatecall
那么这个函数选择器到底对应什么函数名呢?我们可以去Ethereum Signature Database找找,最后发现匹配上了drain(),由此我们就知道完整的攻击路径了:
4. 攻击路径
首先部署恶意合约,里面必须包含
drain()函数,其目的是提走合约内的所有ETH,比如payable(OWNER).call{value: address(this).balance}("");,需要注意由于是delegatecall,因此这里的OWNER最好硬编码然后使用恶意合约调用
SimpleVault.deposit()存入少量wei,经过实际测算得到Metadata Hash所在的PC为0x04A1,因此要存入0x04A1=1185 wei用于触发JOP最后构造calldata,例如:
1
2
3
4
5bytes memory mangledCalldata = abi.encodePacked(
SimpleVault.withdraw.selector,
uint256(100 ether),
uint256(uint160(address(this)))
);然后使用这个calldata调用函数,完成攻击
需要注意一下,由于
SimpleVault实现了receive(),因此它的属性实际上是自带payable的,而恶意合约如果不带receive()函数可能触发类型不一致的错误,导致delegatecall失败,因此编写恶意合约时请务必添加上receive()函数
5. 参考exp
参考的exp合约如下:
1 | // SPDX-License-Identifier: MIT |
后记
能看出来某人在这一年属于是彻底荒废掉了…不管是题目还是exp都是AI写的,甚至连Writeup都是一股AI味,我真没招了
总之还是厚着脸皮讲一下每道题的神秘小巧思和神秘小背景吧
STARTLINER
玩音击玩的
因为过于懒而且考虑到大部分同学没有手台,所以最后采用了4K的玩法,当然如果搞成In Falsus的话那也太变态了(
谱面基本都是参考的前人的经验,包括但不限于osu!mania上已有的坟场谱、CHUNITHM的红/紫谱、音击本家红/紫谱等
比如Recollect Lines的副歌段面条就是全盘抄的坟场谱,因为我没那个实力能写出那种面条配置
出这道题有两个原因:
- 缺签到题,毕竟Ethereum History前面几关被Legacy Transaction硬控了,会麻烦很多
打中二的ENDYMION紫谱打嗨了,然后重温DDR本家的Babylon’s Galaxy上头了,想写点变速谱+血条挑战恶心人了
Fruit Market
可以看到我的靶机名称上面加了个buffed,这个是因为GPN是德国的比赛,当时我在打的时候其实本地已经打通了,但是由于没有德国的节点导致socketio时有时无,根本没法打,担心原题搬上去也是这种情况,所以想着顺带buff一下
不过最后发现buff后效果不如原来的好,而且实际上不需要buff,因此最后调整回原题的形式了,这下真是小丑竟是我自己了
NEM Shenzhen
我本人不玩CS,但是不妨碍我很喜欢看CS比赛,尤其是出题那段时间S赛和Major众多,因此这题就neta了一下IEM系列赛(笑)
整道题目实际上就是一盘饺子,而那一碟醋就是EIP-7702,主要是想起来很早的时候有遇见一道题,是让某个合约在runtime bytecode长度在大于30小于300的时候完成一系列功能,那个时候刚接触Solidity,所以没能想到可以利用代理合约解决这个问题,然后就想起来7702甚至能让字节码长度只有23就能实现代理合约的功能,于是就有了这题,NFT那一块就是套个壳,甚至检测用的合约都非常敷衍(笑)
这题的3个flag都是来自拯救寒王的那个ESL小剧场,笑没边了,大表哥属于是救对了
ASTERISM Protocol
唉音击批,其实题目里出现的所有“人”出处都是音击,甚至马甲ASTERISM也是从音击来的(江江✌~)
这题实际上来源于我遇到的2个事情,一个是去年每日签到时碰到的那个私钥泄露事件,另一个是今年某垃圾比赛举行期间某师傅对所有参赛队伍的数据分析repo被要求删库,后者我就不指路了,我小号录了视频
这题说是Blockchain,实际上更像是Misc/Forensics,不过本意是希望同学们能注意不要泄露敏感信息,然后记得多用gitignore,只是希望题目别太猜谜了(但愿如此吧…)
Ethereum History
题目灵感来源自四月Diverse System社的新专《AD:Piano X》的压轴曲:削除的“Piano History”,曲子本身是使用不同时期的风格去展示同一段旋律的不同表现,作为压轴曲只能说实至名归
这道题也是希望能展示Ethereum安全的发展史,不过我觉得题目确实不能算是很好,不过好在只是Introduction性质的题目,所以不出太难太猜应该也能勉强算得上是无功无过
整道题相比之前的题目有一个非常显著的特点:为了还原当时的Ethereum环境,每一小问的硬分叉版本都需要变更,同时也说明合约的Solidity版本也需要更改,但是我总不可能像v1~v3那样去给每个版本下一个solc然后重命名去使用吧,所以这次v4进行了改动,就是从Docker缓存层里面获取编译合约那一层的solc并复制到python运行的那一层,这样solc版本差异的麻烦就可以迎刃而解了,之后也不用再去下solc binary了
除此之外部分EIP也因为硬分叉版本问题会存在兼容问题,这个不仅在解题时有体现(London分叉前无法使用Txn Type 2的交易),题目的部署其实也有体现。当时在设计如何部署题目的时候确实有点麻烦,首先就是常用的forge-std不支持0.4之类的早期版本,不过最后还是使用了Setup合约的古法操作,稳定而且不容易出错,而且靶机里面是会保存编译后的文件的,不用白不用,直接用System Address发送部署交易就行了
考虑到每一题的硬分叉版本都不同,所以最后干脆把创建Anvil链和部署题目合约绑定了(更新实例本质上也是重新创建Anvil链和部署题目),除此之外为了防止每一个新的Anvil链都要随机一个不同的私钥(更改地址私钥这些很麻烦),所以同一个Docker下的所有小问都使用同一组助记词,当然这也说明System Address固定,因此Setup的地址也是固定的,唯一的问题就是更新实例的时候看不出来靶机更新了,虽说就只是一个逻辑判断的差别,不过我懒得搞了(
AuroraSFS
这题就是我前面提到的想搓一个Layer 2的题目,但是很明显我摆烂了,what can I say
本来一开始和AI设计的时候是想着这样一个场景的:Osaka硬分叉刚推出,Layer 2没有及时更新,导致CLZ操作码在Layer 2无法执行,但是Layer 2肯定会有一个过渡方案,然后这个方案里面某个逻辑有问题导致CLZ处理边缘情况的时候没有进行合理的操作,最终能进行exploit
理想很丰满,现实嘛…烂完了😅
虽然这题说是CLZ当考点,但是根本原因还是整型溢出,而且这个bitmap的设计也是十分有问题,感觉题目质量是这些题目里面最差的…唯一的好消息可能就是从这题开始对靶机整体换新了吧,因为之前用的模板最高只支持Prague链,现在已经可以支持Osaka链了,而且去掉了一些七七八八的东西,就是靶机莫名其妙变大了100M…
いちげき!&Nexus Stellaris系列
也算是我的一个夙愿,自从25年二开了Solidity靶机模板后就一直想着出一道跨链桥的题目,而且出完跨链桥也勉强算得上是全覆盖了:从早期的合约漏洞,到字节码,最后到简单但是比较完善的一个协议,某种程度上也算是大满贯了,出题中间也学到了很多东西,DevSecOps都或多或少有一定成长(应该吧…)
《堵桥来》其实是我在设计Flumina Stellaria过程中的一个副产物,可以理解为这个是初代设计,NS:FS是第二代。因为初代设计并没有体现出“跨链”这个特点,所以一开始是准备被deprecate的,但是后面想想感觉作为一个过渡的题目好像也不是不行,所以就留下来了,至少我觉得比SFS那题质量高出不少
至于NS:VS为什么会想着把跨链桥和DevOps结合在一起(而且还是单镜像),这个有两层因素,第一层就是我确实想这么干,第二个则是目前绝大部分的CTF靶场平台都不支持多容器多镜像题目,虽然近段时间ret2shell开源了,但是毕竟题目的框架之类的都已经基本设计好了,如果大幅度重构的话耗Token(笑),因此还是作罢。当然现实生活中不会像这道题这样把所有的组件挤在一个服务器里面,换句话说就是“把所有的鸡蛋放在同一个篮子里”,不过新生赛嘛,稍微脱离现实一点点应该问题不是太大,而且如果让我自己搞个VPS搭k8s搞容器分发的话,没必要,毕竟根据23~25年一共三年的观察,没啥人做Blockchain,也没啥人能做到5⭐,所以倒也无所谓了
当然除去这些,这道题还添加了我对C2合约的一个初步的设想(怎么感觉像是在炫技www,不过没啥技术含量就是了),毕竟如果只是单单把合约当作一个存放载荷和组件的存储桶未免也太浪费了,但是感觉还是发送交易更加浪费一点,但是但是近段时间EtherHiding又有新的技术迭代了,叫NullReceiver,这个我会补充一下博客,毕竟思路其实也非常简单
其实一开始这些题并没有打算公开,毕竟还是想藏一点东西,但是后面想了想,没必要(也不知道之前在矫情个啥),而且技术本身是中立的,最后还是得看使用者,所以还是决定全公开,当然这也意味着之前写的那篇有关区块链恶意软件的博客也将会在新生赛结束后取消加密(毕竟也过了一年了,那些真研究的也都研究过了)
量子力学のためのDeFiシステム
如题目名所见,“为量子力学而作DeFi系统”,题目名来自Cansol和Raimukun的“量子力学のためのピアノ協奏曲”(为量子力学而作钢琴协奏曲),考点的原型事件是2023年的Curve Finance Hack,虽然最后面发现是Vyper语言存在0day漏洞,但是当时很多文章都说是攻击者利用了只读重入实现的攻击,可惜当时我没看懂,现在搞明白了就想着圆一下梦,不过既然是DeFi系统,AMM肯定是少不了的,而太难的又不好放上去,就还是用的Uniswap V2ヽ( ̄ω ̄( ̄ω ̄〃)ゝ
不过当时设计题目的时候有点上头,把套利的目标设的有点高了(我试过的最高余额是92 ETH,目标是80 ETH),如果自己去进行实际攻击去调整的话真的很麻烦,因此还是让AI写了个模拟器,感觉这题最大的难点就在这里,因为这个约束问题自变量太多了,而且又是非线性的约束问题…
ASTE/RISK: For 10th Aurora
题目名称灵感来自舞萌Kaleidxscope企划的最终曲“Ref:rain (For 7th Heaven)”,我本意没想过vivid/stasis,纯属巧合
至于为什么使用Asterisk(星号)…你可以说它是指针,表示既定规则下的无限可能(别犯法啊xdm),也可以说是繁星,在夜空中熠熠生辉,又或者是什么其它的东西,这个随你想象
然后10th Aurora…嗯…26年刚好是建社10周年,所以就这样写了,包括最后的flag里面其实也是塞了个10TH YEAR在里面的,虽然不是特地为了10周年设计的题目,但是莫名想到“不忘初心”这个词,刚好这题也是那个时期的题目,质量相比其他题目也还说得过去,就这样了
出题的契机是小登在群里聊Pwn(我靠大一小登给新生赛出了道5⭐Pwn你敢信),然后我就在想EVM是不是也可以搞Pwn题玩玩,于是到处搜相关的资料,虽然基本都是在谈Storage collision之类的已经玩烂了的套路,但是最后还是找到了那道EVM JOP,好像还是国人大佬出的题,respect+
本来这题想直接用vm.etch()直接patch字节码的,但是最后还是用了合约工厂,主要还是因为forge script好像不是很能用CREATE操作码部署合约,虽然可以写Yul然后直接编译部署啥的,但还是那一点:能用就行(不过好像constructor传入的参数失效了…?)
整道题最大的难点应该是意识到合约字节码有问题,毕竟首先这是新生赛(谁家新生赛上强度的啊…),其次就是前面的题目都会给小登们一种“先入为主”的观念,会下意识认为题目给的源码就是100%准确的,不会考虑字节码可能存在问题,这种思维惯性才是本题最大的阻碍,所以这题开玩笑地把难度设定为了ε+3⭐,主要就是觉得JOP在AI辅助下应该是很快就能解决的,考虑到技术难度也就3⭐,至于那个ε就看思维惯性有多强大了
同时这道题最后把css改了一下,现在flag是不会超出弹窗范围了
其他
出完量子力学那题刚好SCTF放wp,随手瞄了一眼,结果发现有点撞思路了,难绷…不过硬要说的话感觉DeFi Hack都有点同质化,核心就是那几步,而且我这边有套利规划,再加上我懒得一批,所以就睁一只眼闭一只眼放过去了
然后顺手搜了一下26年其他国内比赛的Blockchain,结果发现好一些7702的题,还有人直接拿公链Hitchhiking(搭便车)这种操作来出题的哦,不是你们都出完了那我出啥😡😡😡我总不可能现学ZK然后考小登ZK漏洞吧
什么?你说Cairo?那个很多漏洞和Solidity互通的(毕竟本质也是Ethereum Layer 2),而且再搞一个Starknet私链Infra还是太麻烦了;至于我的电脑?存储空间说:下次一定(常年空闲磁盘空间<7GB表示已投降)
不过有一点比较可惜,就是跨链桥那里并没有用到zksync的zk特性,如果之后还有机会出题的话再说吧,就当是挖坑了,填不填另说
至于其它给26新生赛的Misc/Forensics题目就不在这里写wp和后记了,应该要么AI梭完了要么没人做(笑)
- 本文作者: 9C±Void
- 本文链接: https://cauliweak9.github.io/2026/07/02/AuroraCTF2026-Blockchain-WP/
- 版权声明: 本博客所有文章除特别声明外,均采用 MIT 许可协议。转载请注明出处!
我爹
我E神
式神
三极管全能神
Marin