随想——从强网拟态到潜在作弊再到区块链出题

创建于：2025-11-07
更新于：2025-11-07

字数统计: 3.7k字 | 阅读时长≈ 15分

简单来说就是对最近这一两周的一个总结

这一切都要从10月25号那天说起…那天学弟们基本上都出去打线下了，所以拟态也就没人看，本来我也不准备上线了，但是突然有人call了我，说强网拟态好像有一道区块链，但是放在了Crypto里面，因此就上号瞄了一眼…

1. 万物起源——强网拟态blockchain赛题

当时一上线看到几个公共靶机链接就没绷住，至于为什么我们后面再说，但是因为咱上线比较晚，所以那个时候已经从公共靶机变为独立靶机了，结果开了靶机连上去，欸，您猜怎么着，404 Not Found

我靠当时就给我气笑了，然后看到公告有个tar包需要自己起，所以跟着公告的命令走了一遍，结果定睛一看，我靠，API可视化工具

当时我人瞬间就懵圈了，哪有区块链不给RPC给API的啊？我甚至都怀疑这是不是区块链题目了，结果一看路由前缀：WeBASE-Front，好家伙，肯定是微众那边的什么神秘东西，八成就是FISCO-BCOS了（事后也确认了就是这坨东西）

总之访问靶机域名/WeBASE-Front路由，就会自动跳转到一个节点控制台，里面包含了题目合约本身：

pragma solidity ^0.4.25;

contract CoinFlip {
  event ConsecutiveWins(address,uint256);
  uint256 public consecutiveWins;
  uint256 private consecutiveWinNumber=10;
  address private winer;
  uint256 private lastNance;
  string private key;
  bool private isStart;

  constructor(string memory _key) {
    require(keccak256(_key)!=keccak256(""),"please input key");
    consecutiveWins = 0;
    key=_key;
    isStart=false;
  }

   modifier onlyEOA()  {
    require(msg.sender==tx.origin,"only EOA");
    _;
  }

  modifier verifyConsecutiveWins(){
    require(isStart==true,"Game is not over");
    require(consecutiveWins==consecutiveWinNumber&&winer!=address(0),"no winner");
    _;
  }

  function flip(bool _guess) public onlyEOA returns (bool,string) {
    require(isStart==false,"Game over!!");
    uint256 nonce=uint256(keccak256(abi.encode(keccak256(lastNance),block.timestamp,blockhash(block.number - 1),block.difficulty,keccak256(tx.origin),keccak256(msg.sender))));
    if (lastNance == nonce) {
      revert();
    }

    lastNance = nonce;
    uint256 coinFlip = uint256(uint256(nonce) % 2);
    bool side = coinFlip == 1 ? true : false;

    if (side == _guess) {
      consecutiveWins++;
      if (consecutiveWins==consecutiveWinNumber){
        winer=msg.sender;
        emit ConsecutiveWins(msg.sender,consecutiveWinNumber);
        isStart=true;
        return (true,key);
      }
      return (true,"");
    } else {
      consecutiveWins = 0;
      return (false,"");
    }
  }
  function verify() verifyConsecutiveWins public view returns(address,uint256,string) {
    return (winer,consecutiveWinNumber,key);
  }
}

我靠，这tm不就是Ethernaut的CoinFlip吗？！

他自己都加了个onlyEOA，但是他甚至都不愿意去修改那神秘的Nonce机制（甚至叫Nance给我看乐了），纯膈应

那说句实话真没啥好说的，就是用Web3py去计算伪随机数然后调用API就行了，真没啥东西

但是这API写的好史啊，但凡给的是RPC我就真写脚本走预期解了，所以我重新看了一下合约…

tmd你把key通过construcotr()传参保存在合约里面是何意味？我靠从上古时代开始就有的签到题现在还有**[CENSORED]**没有吸取教训说是，所以我的目标从预期解写脚本转移到了查看题目合约部署时的那次交易

虽然没有RPC能直接调用，但是节点控制台能直接搜区块信息，这不得给我气笑了？所以剩下的你们也都知道了：我直接获取了合约部署那次交易传入的合约字节码和constructor参数（也就是_key），然后直接秒杀了

从被call上线到做完，整个流程刚好30分钟，包括我下楼拿外卖上楼，赛后从某些渠道了解到这道blockchain的难度分类是困难，困难在哪我请问了，气笑了

因此在Writeup提交截止的那一个瞬间，我在B站小号上发了这个视频：锐评第八届“强网”拟态Crypto方向赛题blockchain

2. 最傻逼的出题错误——flag上链

2.1 初始素材——NewStarCTF 2025 Week 5 INTbug赛题

我印象很深刻，那天是一个周一，学弟在开新生赛的Crypto讲解会（我们刚打完校内新生赛），我在下面捧场

突然想起来自己很长一段时间没看NewStar了，所以闲来无事上线看看有没有什么题目玩玩摸个🐟，然后就看到了这道题：

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SimpleOverflowVault {
    string private flag = "flag{fake_fake_fake}";
    
    mapping(address => bool) public unlocked;
    mapping(address => uint256) public userPoints;
    uint256 public totalPoints;
    mapping(address => uint256) private userSpentPoints;
    
    event PointsAdded(address indexed user, uint256 points);
    event PointsUsed(address indexed user, uint256 points);
    
    constructor() {
        totalPoints = 0;
        userSpentPoints[msg.sender] = 1000;
    }
    
    function addPoints(uint256 points) external {
        require(points > 0, "Points must be greater than 0");
        
        if (userSpentPoints[msg.sender] == 0) {
            userSpentPoints[msg.sender] = 1000;
        }
        
        userPoints[msg.sender] += points;
        totalPoints += points;
        
        emit PointsAdded(msg.sender, points);
    }
    
    function usePoints(uint256 points) external {
        require(points > 0, "Points must be greater than 0");
        require(userPoints[msg.sender] >= points, "Insufficient points");
        
        if (userSpentPoints[msg.sender] == 0) {
            userSpentPoints[msg.sender] = 1000;
        }
        
        userPoints[msg.sender] -= points;
        
        unchecked {
            totalPoints -= points;
            userSpentPoints[msg.sender] -= points;
        }
        
        if (userSpentPoints[msg.sender] > 1000) {
            unlocked[msg.sender] = true;
        }
        
        emit PointsUsed(msg.sender, points);
    }
    
    function getFlag() external view returns (string memory) {
        require(unlocked[msg.sender], "Vault is locked. Trigger integer underflow first!");
        return flag;
    }
    
    function getSpentPoints() external view returns (uint256) {
        return userSpentPoints[msg.sender] == 0 ? 1000 : userSpentPoints[msg.sender];
    }
    
    function resetUser() external {
        uint256 userCurrentPoints = userPoints[msg.sender];
        
        if (userCurrentPoints > 0) {
            unchecked {
                totalPoints -= userCurrentPoints;
            }
            userPoints[msg.sender] = 0;
        }
        
        userSpentPoints[msg.sender] = 1000;
        unlocked[msg.sender] = false;
    }
}

摆明了是一道整型溢出的题目，通过usePoints打整型下溢，还特地用了unchecked块，只能说不能再明显了，中规中矩的一道题

如果只是这样那也没啥，毕竟是新生赛，不可能出太难…

但是！你这家伙把flag放到合约里面上链是何意味？！你tm甚至还是扔到Ethereum Sepolia上的？！我靠我是真的没有想到都2025年了国内的区块链题目还是会有把flag明文传上去的操作出现又给我气笑了

与此同时，我想到了另一个比赛的题目：

2.1 额外素材——LilCTF 2025 生蚝的宝藏赛题

这道题目只告诉你合约的地址和部署合约的交易哈希（请记住这个信息），然后就没了，合约也不给你，让你自己搞

当时我还以为题目有问题，但是用cast能做，因此就算了，于是尝试cast code获取到了合约的字节码，然后反编译得到源码，实际上就是一个异或，flag存在一个mapping里面需要自己去cast storage获取指定存储位置的值，然后提交解密后的treasure，最后得到flag

一切都是那么的平平无奇，直到我突发奇想：你既然要检测，肯定有个明文要去比对，那么肯定会传入我们需要treasure，于是我尝试了cast rpc eth_getTransactionByHash…

tmd还真就是把treasure明文传进合约里面！直接给我气笑了，当时做完了没交（大概是领先一血半个多小时吧），然后去找LilRan师傅问给源码是不是考点的一部分，得到回复是确实是考点的一部分，那么题目大致没啥问题，除了flag上链…

好玩的是，treasure是flag的后半段

总之就单单是flag上链这个弔问题我已经在不同难度梯度，不同规模的比赛里面都见过了，这覆盖面也太广了吧？！没人说，到时候全都这么出题，然后flag上链，题目一出来就被秒杀…受着！

然后各位也就知道了，新的视频素材有了：锐评国内区块链题目出题人的一个小毛病：flag上链

3. Solution——对非预期以及如何规避非预期的讨论

那么提出了问题，不可能完全不给解决方案吧？刚好有位大哥（应该是搞过Sui链那边的CTF题目的）在flag上链的视频的评论区提出了他们的一个解决方案，当时的讨论也是给了我一些新的思考方向，所以又出了一个简单的视频讲了一下当前存在的4类区块链靶机，其架构以及一些可能存在的缺点

由于我懒得再搞一遍图了（我没保存那些图）所以这里就不再展开：胡说瞎扯——CTF区块链靶机框架的四种类型以及简单讨论

简单来说就是推荐每个人独立拥有一条私链，这样就能最大程度避免作弊行为（再有那就是跨队交流的问题了，不在本文的讨论范围内）

虽然这几个视频里面一直在强调共用一条私链可能会有风险，但是想到国内的比赛很多都是共用私链（应该用的是SolidCTF框架），所以我确实有点想打破现在的这个情况，因此我让GPT5提供了一个简单的监控脚本：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
CTF链监控脚本 - solver 检测版
用于演示：同一条Anvil私链上监听他人合约部署和解题状态的可能风险。
"""

import time
import logging
from web3 import Web3
from eth_utils import keccak

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(message)s",
)

RPC_URL = "http://127.0.0.1:8545"
w3 = Web3(Web3.HTTPProvider(RPC_URL))

if not w3.is_connected():
    raise SystemExit("❌ 无法连接到 Anvil 节点，请确认 RPC_URL 正确。")

logging.info("✅ 已连接到私链 (Prague/Cancun compatible).")

# =============== 工具函数 ===============

def selector(sig: str):
    return keccak(text=sig)[:4]

def call_is_solved(addr: str):
    """调用 isSolved() getter。返回 True/False/None"""
    try:
        data = selector("isSolved()")
        res = w3.eth.call({"to": addr, "data": data}, "latest")
        if not res or len(res) < 32:
            return None
        val = int.from_bytes(res[:32], "big")
        return bool(val)
    except Exception:
        return None  # 调用失败，视为非 challenge

def get_contract_creator(addr: str):
    """尝试通过交易追溯创建者"""
    try:
        code = w3.eth.get_code(addr)
        if not code:
            return None
        # 无法直接查交易，简化版留空
        return None
    except Exception:
        return None

# =============== 监控逻辑 ===============

candidate_challenges = {}  # addr -> {"creator":..., "is_solved":bool}

def scan_new_contracts_in_block(block):
    """扫描新部署的合约"""
    for tx in block.transactions:
        if tx.to is None:
            # 合约创建交易
            receipt = w3.eth.get_transaction_receipt(tx.hash)
            addr = receipt.contractAddress
            code = w3.eth.get_code(addr)
            if not code:
                continue
            solved = call_is_solved(addr)
            if solved is None:
                continue  # 不是 challenge
            candidate_challenges[addr] = {
                "creator": tx["from"],
                "is_solved": solved,
            }
            logging.info(f"📦 新候选 Challenge: {addr} (creator={tx['from']}) solved={solved}")

def check_challenges_status(tx):
    """在每笔交易后，检查所有候选 challenge 状态"""
    to_addr = tx["to"]
    frm_addr = tx["from"]
    for addr in list(candidate_challenges.keys()):
        prev_state = candidate_challenges[addr]["is_solved"]
        solved = call_is_solved(addr)
        if solved is None:
            logging.info(f"🧹 移除无效 candidate {addr} （isSolved() 调用失败）")
            candidate_challenges.pop(addr)
            continue
        if not prev_state and solved:
            logging.warning(
                f"🎯 发现解题行为: {addr} 被解出！"
                f" 触发交易: {tx.hash.hex()} | from={frm_addr} | to={to_addr}"
            )
            candidate_challenges[addr]["is_solved"] = True
            # 若 to 不是题目本身，则可能是 solver 合约
            if to_addr and to_addr.lower() != addr.lower():
                logging.warning(f"⚔️ 可能的 solver 合约: {to_addr} 由 {frm_addr} 触发")

# =============== 主循环 ===============

def main():
    latest = w3.eth.block_number
    logging.info(f"🚀 监控启动，从区块 {latest} 开始。")

    while True:
        head = w3.eth.block_number
        if head <= latest:
            time.sleep(1)
            continue

        for n in range(latest + 1, head + 1):
            block = w3.eth.get_block(n, full_transactions=True)
            if len(block.transactions) == 0:
                continue  # 忽略空块
            logging.info(f"🔍 检查区块 {n} ({len(block.transactions)} txs)")
            # 扫描新部署的合约
            scan_new_contracts_in_block(block)
            # 检查所有交易对 candidate 的影响
            for tx in block.transactions:
                check_challenges_status(tx)

        latest = head

if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print("\n🛑 停止监控")

这还只是一个雏形，因为大部分题目有提供合约，所以我们可以自己编译手上的合约然后比对code确认challenge合约，然后存储排布也可以通过分析合约去计算，自动监控题目的解出，然后等待别人发送解题交易，就可以检测到解题的交易，并通过交易的from，to，input等字段数据判断成功解题的队伍如何解题的，进而“偷窃成果”完成“作弊”

上面的脚本只使用了常规的Ethereum JSON-RPC API方法，基本可以说是无感作弊，这也是当前环境下所有队伍共用一条链的一个潜在风险，希望指出这一点能让国内CTF中Ethereum链安全相关的题目能够更进一步

当然我也知道没啥人看我的博客和视频就是了www，总之这是最后一个视频：论区块链题目使用公共私链的潜在作弊手段：链交易监控

本人高度厌恶作弊行为，如果你们有谁用了上面的监控脚本或者我这里给的的思路想搞作弊，最后出问题了，那就受着！你tm活该，打的就是你这种出生o(*≧▽≦)ツ┏━┓

4. 后记——对强网拟态blockchain赛题官方Writeup的锐评

强网拟态的官方Writeup出来了，blockchain那题的Writeup写的一坨细碎：

比赛中途改了题目合约，但是Writeup里面没有修改并提及，仍旧是老版本的onlyExternallyAccount而不是新的onlyEOA
比较重要的伪随机数预测脚本没有写，但是可以一把梭的维吉尼亚密钥爆破脚本写了，侧重点清奇
Solidity代码不放在代码块里面，看的让人头大
旧版的onlyExternallyAccount的缺陷描述完全错误：合约一定存在字节码（就算你用了EIP-7702，你的EOA也有23个bytes的code），包括最小代理模式的代理合约也不是完全没有字节码，没有字节码的是合约部署过程中正在执行constructor()的合约，因为此时还没有将Runtime Bytecode上链
有关lastNance（神tm来个Nance）防重复机制的问题，如果使用的是新版的onlyEOA，是的，它没有效果，但是如果使用的是旧版的onlyExternallyAccount，它就是有效的，因为可以在constructor()中写入重复猜硬币的操作绕过旧版的检测

考虑到出题人写Writeup的上下文，和Ethernaut第3关（CoinFlip）8成相似的代码，外加上flag上链的操作，可以知道本题的出题人压根不懂Solidity，同时还把它扔进Crypto，真的是贻笑大方

但凡来点ecrecover相关的数字签名考点呢？或者CVE-2022-40769那种虚荣地址生成器的密码学漏洞这种好玩的漏洞呢？偏偏选了个最不Crypto的考点，合约还漏洞百出…

这个我也出了视频，在锐评这道题的视频的P2（笑）

本文作者： 9C±Void
本文链接： https://cauliweak9.github.io/2025/11/07/From-Mimic-2-honoring/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！