关于智能合约 Top 10

OWASP 智能合约 Top 10 是一份标准意识文档，旨在为 Web3 开发人员和安全团队提供对智能合约中发现的前 10 个漏洞的深入了解。

它将作为参考，确保智能合约免受过去几年利用/发现的十大弱点的影响。

前10名

• SC01:2023 -重入攻击

• SC02:2023 -整数上溢和下溢

• SC03:2023 -时间戳依赖性

• SC04:2023 -访问控制漏洞

• SC05:2023 -抢先攻击

• SC06:2023 -拒绝服务 (DoS) 攻击

• SC07:2023 -逻辑错误

• SC08:2023 -不安全的随机性

• SC09:2023 - Gas 限制漏洞

• SC10:2023 -未经检查的外部调用

概述

一、重入攻击

机制

可重入过程的一个示例是发送电子邮件。用户可以使用他们喜欢的客户端开始输入电子邮件、保存草稿、发送另一封电子邮件，然后稍后完成消息。这是一个无害的例子。然而，想象一下一个结构不良的用于发出电汇的在线银行系统，其中仅在初始化步骤检查帐户余额。用户可以发起多次转账，而无需实际提交任何转账。银行系统将确认用户的帐户是否有足够的余额用于每次转账。如果在实际提交时没有进行额外的检查，则用户可以提交所有交易，并可能超出其帐户的余额。这是著名的 DAO 黑客攻击中使用的重入漏洞利用的主要机制。

黑客时间！！

让我们从 The DAO 的代码开始，其中特定的操作顺序会造成重入攻击的漏洞。

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.10;

 contract Dao {
mapping(address => uint256) public balances;

functiondeposit() public payable {
require(msg.value >= 1 ether, "Deposits must be no less than 1 Ether");
        balances[msg.sender] += msg.value;
    }

functionwithdraw() public {
// Check user's balance
require(
            balances[msg.sender] >= 1 ether,
"Insufficient funds.  Cannot withdraw"
        );
        uint256 bal = balances[msg.sender];

// Withdraw user's balance
        (bool sent, ) = msg.sender.call{value: bal}("");
require(sent, "Failed to withdraw sender's balance");

// Update user's balance.
        balances[msg.sender] = 0;
    }

functiondaoBalance() public view returns (uint256) {
returnaddress(this).balance;
    }
}so            



        

        

        



     
         

现在让我们检查一下执行该漏洞的黑客的智能合约。

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.10;

interfaceIDao {
functionwithdraw() external ;
functiondeposit()external  payable;
 }

contract Hacker{
IDao dao; 

constructor(address _dao){
        dao = IDao(_dao);
    }

functionattack() public payable {
// Seed the Dao with at least 1 Ether.
require(msg.value >= 1 ether, "Need at least 1 ether to commence attack.");
        dao.deposit{value: msg.value}();

// Withdraw from Dao.
        dao.withdraw();
    }

fallback() external payable{
if(address(dao).balance >= 1 ether){
            dao.withdraw();
        }
    }

functiongetBalance()public view returns (uint){
returnaddress(this).balance;
    }
}

最简单的修复实际上是更改 DAO 的withdraw() 函数中的操作顺序，以便在DAO 合约使用低级调用函数向他们发送以太币之前，调用者的余额重置为 0。

Contract Dao {
…

function withdraw() public {
// Check user's balance
require(
            balances[msg.sender] >= 1 ether,
"Insufficient funds.  Cannot withdraw"
        );
        uint256 bal = balances[msg.sender];

// Update user's balance.
        balances[msg.sender] = 0;

// Withdraw user's balance
        (bool sent, ) = msg.sender.call{value: bal}("");
require(sent, "Failed to withdraw sender's balance");

    }
}

这样，当低级的call()函数触发黑客合约的fallback()函数，并且该函数尝试重新进入withdraw()函数时，黑客的余额在重新进入时为零，并且要求() 方法将评估为 false，从而立即恢复交易。然后，这将导致对 call() 的原始调用移动到 return，并且由于失败，sent 的值将为 false，这将导致下一行 (require(sent, “Failed to有吸引力的发送者的余额”);)恢复。

黑客只会提取他们的存款，仅此而已。

另一种选择是 DAO 合约使用函数修饰符来“锁定”正在执行的withdraw()函数，以便任何重新进入都会被锁阻止。我们通过将这些行添加到 DAO 合约中来实现这一目标。

Contract Dao {
boolinternal locked;

modifier noReentrancy() {
        require(!locked, "No reentrancy");
        locked = true;
        _;
        locked = false;
    }

//……
function withdraw() public noReentrancy { 

// withdraw logic goes here…

    }
}

此重入防护使用所谓的互斥（互斥）标志模式来保护withdraw()函数在前一个调用尚未完成时被调用。因此，当黑客合约的fallback()函数尝试通过withdraw()函数重新进入DAO时，函数修饰符将被触发，其require()函数将导致恢复并显示消息“不可重入”。

结论

当然，这是一个高度简化的演练，它使用示例代码而不是生产示例来解释可重入漏洞利用的概念。虽然我使用 The DAO hack 作为背景来解释可重入 hack，但 The DAO 的实际代码却非常不同。然而，DAO 黑客攻击是基于“可重入”原理，因为黑客会递归地提取资金，而不会更新其余额。

二、整数溢出

整数溢出是当整数数据类型无法保存变量的实际值时发生的一种现象。C 中的整数溢出和整数下溢不会引发任何错误，但程序会继续执行（使用不正确的值），就好像什么也没发生一样，这对于 Solidity 来说也是同样的情况，因为它受 C/C++ 的影响很大。它使溢出错误变得非常微妙和危险。我们将在本文中看到几种检测这些错误的方法。

以太坊虚拟机为整数指定了固定大小的数据类型。这意味着整型变量只能表示一定范围的数字。uint8例如，A只能存储 [0,255] 范围内的数字。尝试存储256到 auint8将导致0. 如果不小心，如果未检查用户输入并且执行的计算导致数字超出存储它们的数据类型的范围，则 Solidity 中的变量可能会被利用。

漏洞

当执行的操作需要固定大小的变量来存储超出变量数据类型范围的数字（或数据段）时，就会发生上溢/下溢。

例如，1从uint8值为 的（8 位无符号整数；即非负）变量中减去0将得到数字255。这是下溢。我们分配了一个低于 的范围的数字uint8，因此结果会回绕并给出 a 可以存储的最大数字uint8。类似地，添加2^8=256到 auint8将使变量保持不变，因为我们已经包裹了 的整个长度uint。这种行为的两个简单类比是汽车中的里程表，它测量行驶距离（在超过最大数字（即 999999）后重置为 000000）和周期性数学函数（在 sin 参数上添加 2π 使值保持不变） 。

添加大于数据类型范围的数字称为溢出。为了清楚起见，添加当前值为 的257a将得到数字。有时将固定大小的变量视为循环变量是有启发性的，如果我们在最大可能存储的数字之上添加数字，我们会从零重新开始，如果我们从零减去，则从最大数字开始倒数。对于可以表示负数的有符号类型，一旦达到最大负值，我们就重新开始；例如，如果我们尝试从值为 的a 中减去，我们将得到。uint801int1int8-128127

这些类型的数字陷阱允许攻击者滥用代码并创建意外的逻辑流。例如，考虑TimeLock.sol中的 TimeLock 合约。

contract TimeLock {

    mapping(address => uint) public balances;
    mapping(address => uint) public lockTime;

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

function increaseLockTime(uint _secondsToIncrease) public {
        lockTime[msg.sender] += _secondsToIncrease;
    }

function withdraw() public {
        require(balances[msg.sender] > 0);
        require(now > lockTime[msg.sender]);
uint transferValue = balances[msg.sender];
        balances[msg.sender] = 0;
        msg.sender.transfer(transferValue);
    }
}

该合约的设计就像一个时间保险库：用户可以将以太币存入合约中，并且它将被锁定至少一周。如果用户选择，可以将等待时间延长至 1 周以上，但一旦存入，用户可以确保他们的以太币被安全锁定至少一周——或者本合同的意图。

如果用户被迫交出他们的私钥，这样的合同可能会很方便地确保他们的以太币在短时间内无法获得。但是，如果用户锁定了100 ether该合约并将其密钥交给了攻击者，则攻击者可以利用溢出来接收以太币，而不管lockTime.

攻击者可以确定lockTime他们现在持有密钥的地址的当前值（它是一个公共变量）。我们就这样称呼吧userLockTime。然后他们可以调用该increaseLockTime函数并将数字作为参数传递2^256 - userLockTime。该数字将被添加到当前值userLockTime并导致溢出，重置lockTime[msg.sender]为0。然后，攻击者可以简单地调用该withdraw函数来获取奖励。

三、时间戳依赖

contract Roulette {
    uint public pastBlockTime; // forces one bet per block

constructor() external payable {} // initially fund contract

// fallback function used to make a bet
function () external payable {
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime); // only 1 transaction per block
        pastBlockTime = now;
if(now % 15 == 0) { // winner
            msg.sender.transfer(this.balance);
        }
    }
}

四、访问控制

在 Solidity 的背景下，访问控制是指用于控制谁可以与智能合约中的某些功能或数据进行交互的机制和模式。Solidity 是一种常用于在以太坊区块链上开发智能合约的编程语言。访问控制对于确保区块链应用的安全性和完整性至关重要。让我们通过 Solidity 中的一个简单示例来探讨这个概念。

如果智能合约没有正确实现访问控制，则可能会使关键功能暴露。这可能允许未经授权的用户执行应受到限制的操作，例如更改合约的状态或提取资金。

示例：Solidity 中的访问控制

假设您正在以太坊区块链上构建一个简单的去中心化投票系统。您希望确保只有符合资格的选民才能投票，并且您希望将计票限制为授权个人。

以下是在 Solidity 中实现访问控制的方法：

pragma solidity ^0.8.0;

contract VotingSystem {
    address public owner;
mapping(address => bool) public eligibleVoters;
    uint256 public totalVotes;
    bool public votingClosed;

constructor() {
        owner = msg.sender; // The contract deployer becomes the owner.
        votingClosed = false;
    }

    modifier onlyOwner() {
require(msg.sender == owner, "Only the owner can perform this action.");
        _; // Continue with the function if the condition is met.
    }

    modifier onlyEligibleVoter() {
require(eligibleVoters[msg.sender], "You are not an eligible voter.");
require(!votingClosed, "Voting is closed.");
        _; // Continue with the function if the conditions are met.
    }

functionaddVoter(address _voter) public onlyOwner {
        eligibleVoters[_voter] = true;
    }

functioncloseVoting() public onlyOwner {
        votingClosed = true;
    }

functionvote() public onlyEligibleVoter {
// Perform the voting logic here.
        totalVotes++;
    }
}

在这个简单的 Solidity 智能合约中：

在这个简单的 Solidity 智能合约中：

1. 有一个owner人部署合约并有权添加合格选民并关闭投票。

2. 我们使用onlyOwner修饰符来确保只有所有者才能调用addVoter和等函数closeVoting。

3. 该onlyEligibleVoter修改器确保只有符合资格的选民才能投票，并且只有在未关闭时才允许投票。

4. addVoter所有者可以调用该函数来添加合格的选民。

5. closeVoting所有者可以调用该函数来关闭投票。

6. 符合资格的选民可以调用该vote函数来投票，但前提是投票仍然开放。

结论

总之，访问控制是 Solidity 编程的一个重要方面，有助于确保智能合约的安全性和完整性。

五、抢先攻击

原文始发于微信公众号（KK安全说）：【智能合约攻击1】使用OWASP Smart Contract Top 10进行智能合约攻击