智能合约开发中13种最常见的漏洞_智能合约的漏洞有哪些

在智能合约开发过程中，确实存在多种类型的漏洞，这些漏洞可能导致资金损失、合约功能失效或被恶意利用。以下是智能合约开发中常见的漏洞类型：

• 1.重入攻击
• 2.整数溢出和下溢
• 3.未授权访问
• 4.不当的继承顺序
• 5.短地址攻击
• 6.断言失败
• 7.代理模式中的初始化漏洞
• 8.时间依赖性漏洞
• 9.Gas限制和DoS攻击
• 10.权限管理不当
• 11.外部调用
• 12.随机数生成
• 13.存储和计算效率

1. 重入攻击：

攻击者利用合约在执行过程中的未锁定状态，通过递归调用合约中的函数，重复提取资金或资源。

示例

我们将使用以太坊的智能合约语言 Solidity 来创建一个简单的捐赠合约，然后展示一个潜在的重入攻击合约。首先，我们创建一个接收捐赠的合约，这个合约有一个余额，并且允许用户提款。这个合约的代码可能看起来像这样

pragma solidity ^0.8.0;

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

    constructor() {
        owner = payable(msg.sender);
    }

    function donate() public payable {
        // 接收捐赠
        balances[msg.sender] += msg.value;
    }

    function withdraw(uint _amount) public {
        require(balances[msg.sender] >= _amount, "Insufficient balance");
        // 这里应该先减少余额，再转账，但是顺序颠倒了
        msg.sender.transfer(_amount);
        balances[msg.sender] -= _amount;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

注意这里的问题是在 withdraw 函数中，我们首先尝试向用户转账，然后才减少他们的余额。这是不安全的，因为转账操作会触发接收方的 receive 或 fallback 函数，这给攻击者提供了机会来调用 withdraw 函数再次提款。

现在让我们创建一个攻击者合约，它可以利用这个漏洞：

pragma solidity ^0.8.0;

contract Attacker {
    VulnerableDonation donationContract;

    constructor(address _donationAddress) {
        donationContract = VulnerableDonation(_donationAddress);
    }

    fallback() external payable {
        if (address(this).balance > 0) {
            // 递归调用 withdraw 函数，只要还有余额就继续提款
            donationContract.withdraw(address(this).balance);
        }
    }

    function attack() public payable {
        // 第一次调用 donate 函数向捐赠合约存入资金
        donationContract.donate{value: msg.value}();
        // 然后立即调用 withdraw 函数开始重入攻击
        donationContract.withdraw(address(this).balance);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

在攻击者合约中，fallback 函数会在接收到资金时自动触发，如果合约中还有余额，它会递归地调用捐赠合约的 withdraw 函数，试图尽可能多地提款，直到没有剩余的资金可以转移为止。

为了确保合约的安全，正确的做法是在转账前减少用户的余额，这可以通过简单地调整 withdraw 函数的顺序来实现：

function withdraw(uint _amount) public {
    require(balances[msg.sender] >= _amount, "Insufficient balance");
    balances[msg.sender] -= _amount;
    // 转账应该在更新状态变量之后
    msg.sender.transfer(_amount);
}
1
2
3
4
5
6

这样，即使攻击者尝试在转账之前再次调用withdraw 函数，他们也会发现自己的余额已经被更新，从而无法再次提款。

2. 整数溢出和下溢：

当数学运算的结果超出整数类型所能表示的范围时，会导致数值错误地回绕，这可以被攻击者利用来获取额外的代币或资源。

溢出示例

假设我们有一个智能合约，它接收用户存款并存储在一个变量中。如果用户尝试存入的金额加上现有的余额超出了整数的最大值（在Solidity中，uint256类型的最大值是2^256-1），就会发生溢出。

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

contract OverflowExample {
    uint256 public balance;

    function deposit(uint256 amount) public {
        balance += amount;
    }

    function getBalance() public view returns (uint256) {
        return balance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

测试溢出

为了测试溢出，我们假设balance已经是uint256类型的最大值，再尝试存入任何正数，都将导致溢出，即结果将从最大值回绕到0。

// 假设balance已经是uint256的最大值
uint256 maxUint256 = type(uint256).max;
balance = maxUint256;
// 尝试存入任何正数都会导致溢出
deposit(1);
// 此时，balance将变为0
1
2
3
4
5
6

下溢示例

下溢通常发生在减法操作中，如果从一个较小的数中减去一个较大的数，结果将低于最小整数值（对于无符号整数，最小值是0），从而导致下溢。

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

contract UnderflowExample {
    uint256 public balance;

    function withdraw(uint256 amount) public {
        balance -= amount;
    }

    function getBalance() public view returns (uint256) {
        return balance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

测试下溢

在无符号整数中，下溢实际上会导致值从0回绕到最大值，但这通常不是预期的行为，因此仍然被视为错误。

// 假设balance为0
balance = 0;
// 尝试取出任何正数都会导致下溢
withdraw(1);
// 此时，balance将变成uint256的最大值
1
2
3
4
5

解决方案

为了避免整数溢出和下溢，Solidity提供了安全数学库SafeMath，它包含了检查溢出和下溢的整数运算函数。自Solidity 0.8.0起，安全数学操作符checkedAdd, checkedSub, checkedMul, 和 checkedDiv被引入，可以自动检测并抛出异常。

using SafeMath for uint256;

function deposit(uint256 amount) public {
    balance = balance.checkedAdd(amount);
}

function withdraw(uint256 amount) public {
    balance = balance.checkedSub(amount);
}
1
2
3
4
5
6
7
8
9

这样，如果检测到溢出或下溢，Solidity将自动抛出异常，阻止交易执行，从而保护合约免受此类错误的影响。

3. 未授权访问：

如果智能合约对关键函数的访问控制不足，攻击者可能执行不应允许的操作，如修改合约状态或提取资金。

未授权访问示例

假设我们有一个智能合约，用于管理用户的存款和提款。在这个例子中，合约没有正确地限制谁可以调用withdraw函数。

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

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

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

    // 缺乏访问控制，任何人都可以调用这个函数
    function withdraw(uint256 amount) public {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        payable(msg.sender).transfer(amount);
        balances[msg.sender] -= amount;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在这个合约中，withdraw函数可以直接被任何地址调用，只要该地址有足够余额即可。但是，如果合约中存在一些逻辑错误或者状态混乱，这可能导致资金被非法提取。

攻击者行为

攻击者可以通过调用withdraw函数，即使他们没有足够的余额，也可能因为某些合约状态的错误而成功提取资金。比如，如果合约中的某个地方错误地增加了攻击者的余额，攻击者就可以利用这一点来提取不属于他们的资金。

解决方案

为了解决未授权访问的问题，我们需要在函数前添加访问修饰符，确保只有特定的角色或地址可以调用withdraw函数。这里我们使用一个简单的onlyOwner修饰符来限制对合约所有者的调用。

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

contract SecureBank {
    address private owner;
    mapping(address => uint256) public balances;

    constructor() {
        owner = msg.sender;
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Only the contract owner can call this function");
        _;
    }

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

    // 使用onlyOwner修饰符限制对所有者的调用
    function withdraw(uint256 amount) public onlyOwner {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        payable(msg.sender).transfer(amount);
        balances[msg.sender] -= amount;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

现在，只有合约的创建者（即owner）可以调用withdraw函数。这防止了未授权的用户直接提取资金，提高了合约的安全性。
注意，这种简单的访问控制机制可能不足以应对复杂的场景，你可能需要更复杂的角色和权限系统，比如使用OpenZeppelin的Ownable和AccessControl库来提供更细粒度的访问控制。

4. 不当的继承顺序：

在智能合约开发中，不当的继承顺序可能会导致意料之外的行为，尤其是在处理权限控制和函数覆盖时。当一个合约从多个父合约继承时，构造函数的执行顺序和函数的覆盖规则变得尤为重要。

不当继承顺序示例

假设我们有两个合约ParentA和ParentB，以及一个从这两个合约继承的子合约Child。ParentA合约包含了一个构造函数和一个函数setOwner，而ParentB也定义了一个setOwner函数，但其功能不同。我们的目标是让Child合约能够调用ParentA的setOwner函数，但不当的继承顺序会导致调用的是ParentB的版本

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

contract ParentA {
    address public owner;

    constructor() {
        owner = msg.sender;
    }

    function setOwner(address newOwner) public {
        owner = newOwner;
    }
}

contract ParentB {
    function setOwner(address newOwner) public {
        // 这里的实现与ParentA不同，但我们不关心具体细节
    }
}

// 不当的继承顺序
contract Child is ParentB, ParentA {
    // ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

在上述代码中，Child合约继承了ParentB和ParentA。然而，在Solidity中，如果两个父合约定义了同名函数，则继承的顺序决定了哪个函数会被优先覆盖。因此，在Child合约中，setOwner函数实际上是ParentB的版本，而不是我们期望的ParentA的版本。

解决方案

要解决这个问题，我们需要调整继承顺序，确保Child合约能够调用正确的setOwner函数。同时，为了明确指出我们想要调用哪个父合约的函数，我们可以使用Solidity提供的super关键字。

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

contract ParentA {
    address public owner;

    constructor() {
        owner = msg.sender;
    }

    function setOwnerA(address newOwner) public {
        owner = newOwner;
    }
}

contract ParentB {
    function setOwnerB(address newOwner) public {
        // 这里的实现与ParentA不同
    }
}

// 正确的继承顺序
contract Child is ParentA, ParentB {
    // 调用ParentA的setOwner函数
    function setOwner(address newOwner) public {
        ParentA.setOwnerA(newOwner); // 明确调用ParentA的setOwnerA
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

在这个修改后的版本中，Child合约首先继承自ParentA，这意味着ParentA的函数和状态变量会先于ParentB的被初始化。此外，我们重命名了ParentA和ParentB中的setOwner函数以避免命名冲突，并在Child合约中定义了一个新的setOwner函数，它明确调用了ParentA中的setOwnerA函数。

通过这种方式，我们确保了Child合约中的setOwner函数调用的是ParentA的版本，避免了因继承顺序不当导致的函数覆盖问题。

5. 短地址攻击（Short Address Attack）：

短地址攻击（Short Address Attack）在以太坊中是指利用以太坊地址的十六进制格式（40个字符，即20字节）和某些智能合约对地址参数处理不当的漏洞，来执行恶意操作的一种攻击手段。这种攻击主要出现在智能合约没有正确验证地址参数长度的情况下，尽管实际的以太坊地址长度固定，但攻击者可能尝试传递较短的地址字符串，试图欺骗合约执行非预期的功能。

在Solidity中，address类型的变量总是占用20字节，因此直接传递短地址不会导致问题，因为Solidity会自动将其填充至20字节。然而，某些合约可能从外部调用接收数据，如果这些数据被错误地解释为地址，且合约没有正确处理或验证这些数据，就可能发生短地址攻击。

示例，展示了短地址攻击的潜在风险：

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

contract VulnerableContract {
    address public owner;

    constructor() {
        owner = msg.sender;
    }

    // 错误地尝试将任意数据解析为地址
    function setAddress(bytes data) public {
        // 注意：这里使用了一个不安全的方法将数据解析为地址
        // 实际上，如果data的长度小于20字节，这将产生一个无效的地址
        assembly {
            owner := mload(add(data, 0x14)) // 加载20字节的数据并赋值给owner
        }
    }

    function getOwner() public view returns (address) {
        return owner;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

在这个示例中，VulnerableContract有一个公开的setAddress函数，它接受一个bytes类型的参数data，并尝试在低级别汇编中将其解析为一个地址，然后设置为合约的owner。如果攻击者传递的数据长度不足20字节，Solidity会自动填充剩余的字节为0，这可能会导致一个无效的地址被设置为owner。

攻击过程

假设攻击者构造了长度小于20字节的数据（例如，仅包含10字节的有效负载），并调用setAddress函数。虽然Solidity会自动将不足的部分填充为0，但如果合约没有正确地验证和处理这种情况，那么owner可能会被设置为一个非预期的地址，可能是一个无效的地址或一个由攻击者控制的地址。

防御措施

为了防御短地址攻击，智能合约开发应当：

• 1、验证数据长度：确保所有接收的地址数据都是完整的20字节。
• 2、使用类型安全的函数：避免直接使用低级汇编语句处理数据，而是使用类型安全的Solidity函数。
• 3、单元测试：进行详尽的单元测试，包括边界条件和异常情况，确保合约在各种输入下都能正常工作。
• 4、在实际开发中，应避免直接在低级汇编中操作地址，而是使用Solidity提供的安全函数和类型检查来处理地址数据。

6. 断言失败：

断言（assert）在智能合约中用于确保内部逻辑的一致性和正确性，但如果使用不当，确实可能导致意外的合约终止或资金锁定。这是因为assert主要用于检测程序内部的错误，例如算法错误或逻辑错误，它假定这些错误在正常运行时不会发生。一旦assert失败，交易将被立即回滚，且不退还gas费用，这对于合约的用户来说可能是灾难性的，特别是如果这导致了合约的关键功能无法使用。

下面是一个不当使用assert的例子，这可能导致资金锁定：

不当使用assert的示例

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

contract WithdrawalContract {
    address payable public owner;
    uint256 public balance;

    constructor() {
        owner = payable(msg.sender);
        balance = 0;
    }

    receive() external payable {
        balance += msg.value;
    }

    function withdraw(uint256 amount) public {
        assert(msg.sender == owner); // 确保只有合约所有者可以提取资金
        require(balance >= amount, "Insufficient funds"); // 确保有足够的余额
        balance -= amount;
        owner.transfer(amount); // 向所有者转移资金
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

在这个合约中，assert(msg.sender == owner)用于确保只有合约所有者才能调用withdraw函数。然而，如果在合约部署后owner地址被意外地设置为一个无效地址（例如，一个没有私钥的地址），那么assert将永远失败，资金将永久锁定在合约中，因为没有人可以调用withdraw函数来提取资金。

解决方案

为了避免资金锁定的风险，可以考虑以下几种改进策略：

• 1、使用require代替assert：对于用户输入或预条件检查，使用require更为合适，因为它明确表示这是对外部条件的检查，而非内部逻辑错误。

• 2、添加紧急撤资功能：设计一个允许在紧急情况下提取资金的机制，例如，如果owner地址被锁定，可以有一个多重签名的“董事会”来决定如何解锁资金。

• 3、确保合约所有者的可变更性：允许合约所有者更改，以防原始所有者丢失私钥或地址被锁定。

解决方案示例：

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

contract ImprovedWithdrawalContract {
    address payable public owner;
    uint256 public balance;

    constructor() {
        owner = payable(msg.sender);
    }

    receive() external payable {
        balance += msg.value;
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Only the contract owner can call this function");
        _;
    }

    function withdraw(uint256 amount) public onlyOwner {
        require(balance >= amount, "Insufficient funds");
        balance -= amount;
        owner.transfer(amount);
    }

    // 添加一个功能，允许更改所有者
    function changeOwner(address payable newOwner) public onlyOwner {
        owner = newOwner;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

在这个改进后的合约中，我们使用了require来检查条件，并添加了一个changeOwner函数，允许当前所有者在必要时更改所有者地址，从而避免资金永久锁定的风险。

7. 合约代理漏洞

代理模式在智能合约开发中非常常见，尤其是在升级和模块化设计中。代理合约（Proxy Contract）通常用于分离逻辑实现与合约的外部接口，允许在不改变接口的情况下升级或替换底层实现。然而，如果代理合约的初始化过程没有得到妥善处理，就可能成为攻击的入口。

示例：代理合约初始化漏洞

假设我们有如下的代理合约模板，其中implementation变量指向实际执行逻辑的合约地址：

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

contract Proxy {
    address private implementation;

    constructor (address _implementation) {
        implementation = _implementation;
    }

    fallback() external payable {
        address impl = implementation;
        assembly {
            let ptr := mload(0x40)
            calldatacopy(ptr, 0, calldatasize())
            let result := delegatecall(gas(), impl, ptr, calldatasize(), 0, 0)
            assembly {
                let free := mload(0x40) 
                mstore(free, ptr)
                mstore(0x40, add(free, 0x20))
            }
            switch result
            case 0 {
                revert(0, returndatasize())
            }
            default {
                return(0, returndatasize())
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

这个代理合约通过构造函数接受一个实现合约地址并将其存储在implementation变量中。之后，任何发送到代理合约的交易都会被转发到该实现合约。

攻击方向

问题在于，如果构造函数对谁可以设置implementation地址没有适当的限制，攻击者可能会利用这一点，通过发送一笔交易直接调用代理合约的构造函数，从而改变implementation地址，指向他们自己的恶意合约。这样，所有后续调用都将被重定向到恶意合约，导致合约功能被篡改或资金被盗。

解决方案

为了防止这种类型的攻击，我们需要确保代理合约的初始化过程是安全的。以下是一种可能的解决方案：

• 1、使用Initializer Pattern：引入一个初始化状态，确保代理合约只能被初始化一次，并且初始化过程受到严格控制。可以使用一个initializer修饰符来标记那些只应在初始化过程中调用的方法。

• 2、引入所有权验证：确保只有合约的所有者或预定义的地址能够设置implementation。

解决方案示例：

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

abstract contract Initializable {
    bool initialized = false;

    modifier initializer() {
        require(!initialized, "Already initialized");
        initialized = true;
        _;
    }
}

contract SecureProxy is Initializable {
    address private implementation;
    address private admin;

    constructor(address _implementation, address _admin) initializer {
        implementation = _implementation;
        admin = _admin;
    }

    function setImplementation(address _newImplementation) public {
        require(msg.sender == admin, "Only admin can set the implementation");
        implementation = _newImplementation;
    }

    fallback() external payable {
        // ... (same as before)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

在这个改进版本中，我们引入了Initializable抽象合约来管理初始化状态，并在构造函数上应用了initializer修饰符。此外，我们添加了一个setImplementation方法，允许通过合约所有者（admin）来更新implementation地址，进一步增强了安全性。

8. 时间依赖漏洞

时间依赖漏洞是智能合约中一个常见的安全问题，特别是在以太坊等区块链环境中。这是因为区块链的区块时间戳可以被矿工在一定程度上操纵，这使得依赖于时间戳的智能合约容易受到攻击。攻击者可以通过控制区块时间戳来触发合约中的某些条件，从而获得不公平的优势或造成损失。

示例：贷款合约中的时间依赖漏洞

假设我们有一个基于时间的贷款合约，借款人必须在特定的时间窗口内偿还贷款，否则将面临高额罚息或失去抵押品。合约可能如下所示：

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

contract LoanContract {
    address public borrower;
    uint256 public loanAmount;
    uint256 public deadline;

    constructor(address _borrower, uint256 _loanAmount, uint256 _deadline) {
        borrower = _borrower;
        loanAmount = _loanAmount;
        deadline = block.timestamp + _deadline; // 设置还款截止日期
    }

    function repayLoan() public {
        require(msg.sender == borrower, "Only borrower can repay");
        require(block.timestamp <= deadline, "Deadline passed");

        // 偿还贷款的逻辑...
    }

    function claimCollateral() public {
        require(block.timestamp > deadline, "Deadline not yet passed");
        // 没有偿还贷款，没收抵押品的逻辑...
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

在这个合约中，deadline是基于当前区块时间戳计算的，借款人在deadline之前必须偿还贷款。然而，如果攻击者控制了挖矿过程，他们可以延后提交新区块，人为延长区块时间戳，使deadline看起来还未到达，从而阻止抵押品的没收，或者相反，提前提交新区块，使deadline提前到达，迫使借款人支付罚息。

解决方案

为了解决时间依赖漏洞，可以采用以下几种策略：

• 1、使用Oracle服务：引入一个可信的Oracle服务来提供不可篡改的时间戳，这样可以减少矿工操纵区块时间戳的影响。

• 2、使用链上事件作为时间基准：例如，可以使用特定的区块高度作为时间基准，因为区块高度不能被矿工轻易操纵。

• 3、增加时间缓冲区：在时间相关的逻辑中加入一定的缓冲时间，减少对精确时间戳的依赖。

• 4、使用中位数时间协议（Median Time Protocol，MTP）：类似于比特币网络中的中位数时间协议，可以使用最近多个区块时间戳的中位数来计算一个更稳定的时间参考点。

例如，我们可以修改上面的贷款合约，使用区块高度作为时间基准：

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

contract LoanContract {
    address public borrower;
    uint256 public loanAmount;
    uint256 public deadlineBlock;

    constructor(address _borrower, uint256 _loanAmount, uint256 _deadlineBlocks) {
        borrower = _borrower;
        loanAmount = _loanAmount;
        deadlineBlock = block.number + _deadlineBlocks; // 设置还款截止区块
    }

    function repayLoan() public {
        require(msg.sender == borrower, "Only borrower can repay");
        require(block.number <= deadlineBlock, "Deadline block passed");

        // 偿还贷款的逻辑...
    }

    function claimCollateral() public {
        require(block.number > deadlineBlock, "Deadline block not yet passed");
        // 没有偿还贷款，没收抵押品的逻辑...
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

通过将时间依赖改为区块高度依赖，我们减少了矿工操纵时间戳的能力，从而增强了合约的公平性和安全性。然而，每种解决方案都有其权衡，例如使用区块高度可能会引入与区块生成时间相关的不确定性，因此在实际应用中需要仔细评估和选择最适合的方案。

9. Gas限制和DoS攻击

Gas限制和DoS（Denial of Service，拒绝服务）攻击是在区块链和智能合约环境下常见的安全威胁，尤其是对于像以太坊这样的平台，其中Gas是一种用于衡量执行智能合约成本的单位。Gas机制设计的初衷是为了防止无限循环和资源滥用，但同时也为攻击者提供了可利用的空间。

Gas限制机制

在以太坊中，每一笔交易都会携带一定数量的Gas，这是为了确保任何执行的操作都不会消耗过多的计算资源，从而避免网络拥堵或资源耗尽。当一笔交易开始执行时，它会从交易者提供的Gas总量中扣除费用，直到合约执行完成或Gas耗尽。如果在执行过程中Gas耗尽，那么交易将被回滚，且已经消耗的Gas不会退还给用户。

DoS攻击方式

耗尽Gas

攻击者可以通过构造高复杂度的交易或智能合约来故意消耗大量的Gas，从而使正常交易无法被包含在区块中。例如，攻击者可以创建一个合约，该合约在接收到消息时执行大量计算或存储操作，消耗接近最大Gas限额的Gas量。当许多这样的交易被同时发送到网络时，它们会占据大部分甚至全部的Gas容量，导致其他用户的正常交易无法被确认，从而达到拒绝服务的效果。

无限循环

另一种DoS攻击的方式是通过使智能合约进入无限循环，这将导致Gas立即耗尽，交易失败并回滚。这种攻击通常发生在合约逻辑中存在错误的情况下，例如没有正确处理循环退出条件，或在递归调用中缺少终止条件。当合约进入无限循环时，它会尝试消耗所有可用的Gas，最终导致交易失败，并可能使合约处于不可用状态。

防御措施

为了防御这类DoS攻击，开发者在编写智能合约时需要采取一些预防措施：

1. 限制循环次数：确保任何循环都有明确的终止条件，避免无限循环的可能性。

2. 优化代码效率：尽量减少不必要的计算和存储操作，避免高复杂度的算法。

3. 使用安全框架和库：利用如OpenZeppelin等智能合约安全库，它们通常包含了经过严格审计的安全模式和函数，可以帮助避免常见的安全陷阱。

4. 代码审查和测试：定期进行代码审查和安全审计，使用形式化验证工具检查潜在的漏洞。

5. 设置Gas上限：在智能合约调用中设置合理的Gas上限，避免恶意调用消耗过多资源。

6. 动态Gas定价：考虑实施动态的Gas定价机制，根据网络负载自动调整Gas价格，以鼓励优先处理重要交易。

通过以上这些措施，可以显著降低智能合约遭受DoS攻击的风险，保障网络的稳定性和用户的资产安全。然而，由于区块链环境的复杂性，持续的安全意识和最新的安全实践是必不可少的。

漏洞合约示例

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

contract InfiniteLoopVulnerable {
    function loopUntilZero(uint256 startValue) public payable {
        uint256 currentValue = startValue;
        while (currentValue > 0) {
            currentValue--;
        }
        // 正常操作...
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

在这个合约中，loopUntilZero函数将进入一个无限循环，如果startValue设置得足够大，那么这个循环会消耗所有可用的Gas，导致交易失败并回滚。

攻击演示

攻击者可以调用loopUntilZero函数，传入一个极大的数值，例如2^256-1，这将使循环几乎不可能结束，因此消耗所有的Gas。

InfiniteLoopVulnerable contract = new InfiniteLoopVulnerable();
contract.loopUntilZero(2**256-1);
1
2

防御措施

为了防止这种无限循环的DoS攻击，我们需要在合约设计中加入一些限制和优化：

• 1、限制循环次数：可以设定一个最大循环次数的上限，以避免无限循环的发生。

• 2、检查和修复逻辑：确保循环中有正确的退出条件。

• 3、Gas效率优化：尽可能减少每次循环中的操作，以降低Gas消耗。

下面是一个修复后的合约示例：

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

contract SafeInfiniteLoop {
    function safeLoopUntilZero(uint256 startValue) public payable {
        require(startValue <= 10000, "Value too large"); // 设定最大循环次数
        uint256 currentValue = startValue;
        while (currentValue > 0) {
            currentValue--;
        }
        // 正常操作...
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

10. 权限管理不当 ：

权限管理不当是智能合约中常见的安全问题之一，尤其是在管理员或特定账户被过度赋予权限的情况下。如果合约中的关键功能，如转移资产、修改合约状态或升级合约逻辑，可以被未经授权的实体随意操作，这将构成严重的安全风险。下面我将给出一个示例，展示权限管理不当可能导致的后果，以及如何通过合理设计来缓解这种风险。

漏洞合约示例

假设我们有一个智能合约，用于管理一个数字资产的发行和转账。在这个合约中，管理员账户被赋予了无限的权力，可以无限制地铸造新资产并将其转移到任意账户。

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

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

    constructor() {
        admin = msg.sender;
    }

    function mint(address to, uint256 amount) public {
        require(msg.sender == admin, "Only admin can mint");
        balances[to] += amount;
    }

    function transfer(address from, address to, uint256 amount) public {
        require(balances[from] >= amount, "Insufficient balance");
        balances[from] -= amount;
        balances[to] += amount;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在这个合约中，mint函数允许管理员账户无限制地创建新资产。虽然这看起来像是一个合理的权限，但如果管理员账户的安全性受损，或者合约开发者错误地将一个不受信任的地址设置为管理员，这将为攻击者打开大门。

攻击演示

攻击者可能通过各种手段获取管理员账户的私钥，或者合约开发者可能不小心将一个恶意地址设置为管理员。一旦攻击者控制了管理员账户，他们就可以随意调用mint函数，无限制地创建资产并将其转移到自己的账户，从而非法获利。

MismanagedPermissions contract = new MismanagedPermissions();
contract.mint(msg.sender, 1000000); // 攻击者铸造大量资产
1
2

解决方案

为了防止权限管理不当导致的安全问题，我们可以采取以下措施：

• 1、最小权限原则：只授予执行特定任务所需的最小权限。例如，管理员可以被授予- - 2、铸造资产的权限，但这种权限应该是有限的，例如每天只能铸造一定数量的资产。

• 3、多因素认证：引入多签机制或多因素认证，即使一个管理员账户被攻破，也需要多个独立的批准才能执行关键操作。

• 4、权限审计日志：记录所有权限使用情况，以便于监控和审计。

• 5、权限时效性：设定权限的有效期，过期后需要重新授权。

下面是一个改进后的合约示例，其中增加了权限限制和多签机制：

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

contract SafePermissions {
    mapping(address => uint256) public balances;
    mapping(address => bool) public admins;
    uint256 public dailyMintLimit;
    uint256 public dailyMinted;

    constructor(uint256 _dailyMintLimit) {
        dailyMintLimit = _dailyMintLimit;
        admins[msg.sender] = true; // 初始管理员
    }

    modifier onlyAdmin() {
        require(admins[msg.sender], "Only admin can perform this action");
        _;
    }

    function mint(address to, uint256 amount) public onlyAdmin {
        require(dailyMinted + amount <= dailyMintLimit, "Daily mint limit exceeded");
        balances[to] += amount;
        dailyMinted += amount;
    }

    function addAdmin(address newAdmin) public onlyAdmin {
        admins[newAdmin] = true;
    }

    function removeAdmin(address adminToRemove) public onlyAdmin {
        delete admins[adminToRemove];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

在这个改进后的合约中，我们引入了多个管理员的概念，并设置了每日铸造资产的上限，以防止无限量的资产创造。同时，我们还提供了添加和移除管理员的功能，这需要现有管理员的权限。

通过这些改进，我们可以大大增强合约的安全性，减少权限管理不当的风险。在实际应用中，还需要结合具体的业务场景和安全需求，进一步细化权限管理和安全控制机制。

11. 外部调用 ：

在智能合约开发中，调用不受信任的外部合约是一个常见的安全风险点。这是因为，当你调用另一个合约的函数时，你实际上是在执行那个合约的代码，而这可能会引入你未曾预料的行为，包括恶意行为。下面我将通过一个示例来说明这一风险，并提出相应的缓解策略。

漏洞合约示例

假设我们有一个智能合约，它允许用户通过调用一个外部合约来完成某种任务，比如兑换代币。这里，我们假设外部合约提供了一个transferFrom函数，用于从一个账户向另一个账户转移代币。

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

contract ExternalCallVulnerable {
    address public externalTokenContract;

    constructor(address _externalTokenContract) {
        externalTokenContract = _externalTokenContract;
    }

    function exchangeTokens(uint256 amount) public {
        IERC20(externalTokenContract).transferFrom(msg.sender, address(this), amount);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在这个合约中，exchangeTokens函数调用了外部合约的transferFrom函数。然而，这里存在一个潜在的问题：外部合约可能包含恶意代码，或者其逻辑可能与预期不符，导致资金损失或其他不良后果。

攻击演示

攻击者可以通过部署一个恶意的ERC20代币合约，并将这个合约地址传递给我们的合约。恶意合约可能在transferFrom函数中包含额外的逻辑，比如在转移代币的同时，调用我们的合约中的其他函数，或者执行一些未授权的操作。

// 恶意合约示例
contract MaliciousToken is IERC20 {
    function transferFrom(address, address, uint256) public override returns (bool) {
        // 正常转移代币逻辑...

        // 执行额外的恶意操作，例如调用合约中的其他函数
        ExternalCallVulnerable(0x...).someUnsafeFunction();

        return true;
    }
}
1
2
3
4
5
6
7
8
9
10
11

当用户尝试通过我们的合约交换恶意合约中的代币时，恶意合约的transferFrom函数会被调用，执行恶意操作。

解决方案

为了减轻外部调用带来的风险，我们可以采取以下措施：

• 1、代码审查：在允许调用外部合约之前，对其进行彻底的代码审查，确保其逻辑符合预期，没有包含恶意代码。

• 2、白名单机制：只允许调用经过验证的、可信任的合约列表。这样，即使出现新的恶意合约，也无法通过我们的合约进行调用。

• 3、使用安全库：利用如OpenZeppelin等安全库中的标准化接口，这些接口通常已经考虑到了安全性和兼容性问题。

• 4、限制调用深度：避免在调用外部合约时再次调用其他外部合约，以防止递归调用导致的攻击。

• 5、事件监听与异常处理：在调用外部合约时，监听返回值和异常，确保调用成功并且没有发生异常行为。

下面是一个改进后的合约示例，其中实现了白名单机制：

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

interface IERC20 {
    function transferFrom(address, address, uint256) external returns (bool);
}

contract SafeExternalCall {
    mapping(address => bool) public approvedContracts;
    address public externalTokenContract;

    constructor(address _externalTokenContract) {
        approveContract(_externalTokenContract);
        externalTokenContract = _externalTokenContract;
    }

    function exchangeTokens(uint256 amount) public {
        require(approvedContracts[externalTokenContract], "Contract not approved");
        IERC20(externalTokenContract).transferFrom(msg.sender, address(this), amount);
    }

    function approveContract(address contractAddress) public {
        approvedContracts[contractAddress] = true;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

在智能合约开发中，调用不受信任的外部合约是一个常见的安全风险点。这是因为，当你调用另一个合约的函数时，你实际上是在执行那个合约的代码，而这可能会引入你未曾预料的行为，包括恶意行为。下面我将通过一个示例来说明这一风险，并提出相应的缓解策略。

漏洞合约示例

假设我们有一个智能合约，它允许用户通过调用一个外部合约来完成某种任务，比如兑换代币。这里，我们假设外部合约提供了一个transferFrom函数，用于从一个账户向另一个账户转移代币。

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

contract ExternalCallVulnerable {
    address public externalTokenContract;

    constructor(address _externalTokenContract) {
        externalTokenContract = _externalTokenContract;
    }

    function exchangeTokens(uint256 amount) public {
        IERC20(externalTokenContract).transferFrom(msg.sender, address(this), amount);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在这个合约中，exchangeTokens函数调用了外部合约的transferFrom函数。然而，这里存在一个潜在的问题：外部合约可能包含恶意代码，或者其逻辑可能与预期不符，导致资金损失或其他不良后果。

攻击演示

攻击者可以通过部署一个恶意的ERC20代币合约，并将这个合约地址传递给我们的合约。恶意合约可能在transferFrom函数中包含额外的逻辑，比如在转移代币的同时，调用我们的合约中的其他函数，或者执行一些未授权的操作。

// 恶意合约示例
contract MaliciousToken is IERC20 {
    function transferFrom(address, address, uint256) public override returns (bool) {
        // 正常转移代币逻辑...

        // 执行额外的恶意操作，例如调用合约中的其他函数
        ExternalCallVulnerable(0x...).someUnsafeFunction();

        return true;
    }
}
1
2
3
4
5
6
7
8
9
10
11

当用户尝试通过我们的合约交换恶意合约中的代币时，恶意合约的transferFrom函数会被调用，执行恶意操作。

安全改进

为了减轻外部调用带来的风险，我们可以采取以下措施：

1. 代码审查：在允许调用外部合约之前，对其进行彻底的代码审查，确保其逻辑符合预期，没有包含恶意代码。

2. 白名单机制：只允许调用经过验证的、可信任的合约列表。这样，即使出现新的恶意合约，也无法通过我们的合约进行调用。

3. 使用安全库：利用如OpenZeppelin等安全库中的标准化接口，这些接口通常已经考虑到了安全性和兼容性问题。

4. 限制调用深度：避免在调用外部合约时再次调用其他外部合约，以防止递归调用导致的攻击。

5. 事件监听与异常处理：在调用外部合约时，监听返回值和异常，确保调用成功并且没有发生异常行为。

下面是一个改进后的合约示例，其中实现了白名单机制：

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

interface IERC20 {
    function transferFrom(address, address, uint256) external returns (bool);
}

contract SafeExternalCall {
    mapping(address => bool) public approvedContracts;
    address public externalTokenContract;

    constructor(address _externalTokenContract) {
        approveContract(_externalTokenContract);
        externalTokenContract = _externalTokenContract;
    }

    function exchangeTokens(uint256 amount) public {
        require(approvedContracts[externalTokenContract], "Contract not approved");
        IERC20(externalTokenContract).transferFrom(msg.sender, address(this), amount);
    }

    function approveContract(address contractAddress) public {
        approvedContracts[contractAddress] = true;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

在这个改进后的合约中，我们添加了一个approvedContracts映射，用于存储经过审批的外部合约地址。只有当外部合约地址被列入白名单时，才能通过我们的合约进行调用。

通过这些改进，我们可以大大降低因调用不受信任的外部合约而引入的安全风险。然而，在实际应用中，还需要持续关注新的安全威胁和最佳实践，以维护合约的安全性。

12. 随机数生成

一般在区块链上的随机数生成通常难以实现，依赖于区块哈希等可预测因素，这可能导致攻击者能够预测结果、以下是一些比较常见的场景。

1. 预测随机数

contract GuessTheNumber {
    function guess(bool isHigher) public {
        uint256 randomNumber = block.timestamp % 100; // 这里使用时间戳作为随机数来源
        if ((randomNumber > 50) == isHigher) {
            // 玩家猜对了，分配奖励
        }
    }
}
1
2
3
4
5
6
7
8

攻击者可以通过监控区块链上的交易和时间戳来预测未来交易的时间戳，从而预测随机数并始终做出正确的猜测。

2. 交互式随机数生成

contract Auction {
    function endAuction() public {
        uint256 random = ExternalRandomService.getLastBlockHash() % bidders.length;
        // 假设bidders是一个数组，random用来选择获胜的投标人
    }
}
1
2
3
4
5
6

攻击者可以观察到合约即将结束拍卖的交易，然后在合约调用getLastBlockHash()之前提交一个自己的交易，影响区块哈希，从而影响最终的随机数。

3. 依赖预言机

contract Game {
    function play() public {
        uint256 random = OracleService.getRandomNumber();
        // 使用预言机提供的随机数
    }
}
1
2
3
4
5
6

如果预言机服务被攻击者控制，他们可以提供虚假的随机数，影响游戏结果。

建议方案

要解决上述问题，可以采用以下几种策略：

• 1、使用可信预言机：选择信誉良好的预言机服务提供商，最好是经过审计且有良好历史记录的服务。
• 2、多因素随机数生成：结合多个难以预测的因子来生成随机数，如区块难度、区块头信息以及链下提供的熵。
• 3、时间延迟：在生成随机数和使用随机数之间加入延迟，使得攻击者难以实时预测结果。
• 4、链下随机数生成：使用链下随机数生成服务，然后通过预言机将结果提交到链上。
• 5、加密技术：使用密码学技术，如同态加密或零知识证明，来确保随机数生成过程的隐私性和安全性。

13.存储和计算效率

不当的存储结构或计算密集型操作可能导致高Gas费用和性能瓶颈。
1

示例场景：频繁读取和写入大数组

假设你正在构建一个投票系统，其中每个提案都有一个独立的计票器。为了实现这一点，你可能最初会考虑使用一个映射（map），其中键是提案ID，值是一个数组，存储所有投给该提案的选民地址。

// 不当的存储结构
contract VotingSystem {
    mapping(uint => address[]) public voters;

    function vote(uint proposalId, address voter) public {
        voters[proposalId].push(voter);
    }

    function getVotesCount(uint proposalId) public view returns (uint) {
        return voters[proposalId].length;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

存在的问题

• 1、Gas费用高昂：每当有人投票时，数组需要重新分配内存空间来容纳新元素，这会消耗大量Gas。
• 2、性能瓶颈：读取和写入大数组会变得非常缓慢，因为每次读取或写入操作都需要遍历整个数组。

解决方案：优化存储结构

优化建议
为了减少Gas费用并提高性能，我们可以重新设计数据结构，使用映射来追踪每个选民是否已经投票给某个提案，而不是维护一个选民数组。

// 优化后的存储结构
contract OptimizedVotingSystem {
    mapping(uint => mapping(address => bool)) public hasVoted;

    function vote(uint proposalId, address voter) public {
        require(!hasVoted[proposalId][voter], "Already voted");
        hasVoted[proposalId][voter] = true;
    }

    function getVotesCount(uint proposalId) public view returns (uint) {
        uint count;
        for (address voter = address(1); voter != address(0); voter = address(uint(voter) + 1)) {
            if (hasVoted[proposalId][voter]) {
                count++;
            }
        }
        return count;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

改进说明

• 1、减少Gas费用：使用映射追踪投票状态比维护数组更高效，因为映射的操作（如插入和查找）通常更快，消耗的Gas更少。
• 2、提升性能：映射操作几乎恒定时间复杂度O(1)，不会随数据量增加而变慢。

注意事项

尽管使用映射可以显著提高效率，但在getVotesCount函数中遍历所有地址来计算投票数仍然是低效的。实际应用中，你可以引入额外的映射或变量来追踪每个提案的投票总数，以避免全地址空间的遍历。

// 进一步优化
contract FurtherOptimizedVotingSystem {
    mapping(uint => mapping(address => bool)) public hasVoted;
    mapping(uint => uint) public votesCount;

    function vote(uint proposalId, address voter) public {
        require(!hasVoted[proposalId][voter], "Already voted");
        hasVoted[proposalId][voter] = true;
        votesCount[proposalId]++;
    }

    function getVotesCount(uint proposalId) public view returns (uint) {
        return votesCount[proposalId];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

这样，每次投票时只需更新投票计数器，大大降低了Gas费用和提高了查询速度。在智能合约开发中，合理的设计和优化存储结构对于降低成本和提升性能至关重要。