智能合约变量储存机制详解 - zpan

admin 2021年12月31日14:45:29评论162 views字数 6565阅读21分53秒阅读模式

0x01 前言

最近在研究以太坊存储机制,写一篇文章总结一下

0x02 存储机制

每个在以太坊虚拟机(EVM)中运行的智能合约的状态都在链上永久地存储着。这些值存储在一个巨大的数组中,数组的长度为2^256,下标从零开始且每一个数组能够储存32字节(256个比特)长度的值。并且存储是稀疏的,并没有那么密集。

0x03 变量类型

Solidity的数据变量类型分为两类

  • 值类型-value type
  • 引用类型-reference type

下面列举常用的变量类型

值类型

  • 布尔型(bool) 2bit(0/1)
  • 整型(int/uint) 根据关键字的不同表示不同长度,int8表示8bits有符号数
  • 定长浮点型(fixed/ufixed) Solidity 还没有完全支持定长浮点型。可以声明定长浮点型的变量,但不能给它们赋值或把它们赋值给其他变量
  • 地址类型(adress) 160bits
  • 地址类型成员变量(balance,transfer....)
    • .balance uint256(256bits)
    • transfer() uint256(256bits)
  • 定长字节数组(byte[1]/bytes[1]) 定义数组时定义长度

引用类型

  • 不定长字节数组类型(bytes[]/byte[],string,uint[]....)

  • 结构体(struct)

  • 映射(mapping)

0x04 简单分析

写一个简单值类型的合约

pragma solidity ^0.4.25;

contract TEST{
    bool a=false;
    bool b=true;
    int16 c=32767;
    uint16 d=0x32;
    byte e=10;
    bytes1 f=11;
    bytes2 g=22;
    uint h=0x1; //uint是uint256的简称
    address i=0xbc6581e11c216B17aDf5192E209a7F95a49e6837;
}

优化存储原则:如果下一个变量长度和上一个变量长度加起来不超过256bits,它们就会存储在同一个插槽里

根据交易查询到的存储在以太坊虚拟机上面的值,下面进行分析

0x0000000000000000000000000000000000000000000000160b0a00327fff0100 slot0
//0x00 a false
//0x01 b true
//0x7fff c 32767
//0x0032 d 0x32
//0x0a e 10
//0x0b f 11
//0x0016 g 22
0x0000000000000000000000000000000000000000000000000000000000000001 slot1
// h 0x1
0x000000000000000000000000bc6581e11c216b17adf5192e209a7f95a49e6837 slot2
// i 0x2

从上面可以看出

  • 各个类型的存储长度
  • 存储顺序从后往前
  • 存储优化原则
  • byte.length==bytes1.length==8bits

0x05 数组类型

定长数组

pragma solidity ^0.4.25;

contract TEST{

    bytes8[5] a = [byte(0x6a),0x68,0x79,0x75];
    bool b=true;
}

可以看的我虽然规定了了长度为5,但是实际上只用了4个,所以就只是用了四个bytes8的空间

是不是可以加一个,编译器会报错

变长数组

pragma solidity ^0.4.25;

contract TEST{
    uint[] a=[0x77,0x88,0x99];
    function add(){
        a.push(0x66);
    }
}

根据交易查询到的存储在以太坊虚拟机上面的值,下面进行分析

0x0000000000000000000000000000000000000000000000000000000000000003 slot0
//存储的是数组a的长度3
0x0000000000000000000000000000000000000000000000000000000000000077 slotx
//a[0]
0x0000000000000000000000000000000000000000000000000000000000000088 slot(x+1)
//a[1]
0x0000000000000000000000000000000000000000000000000000000000000099 slot(x+2)
//a[2]

Storage Address的由来 x=keccak_256(slot) slot是指数组长度存储的位置,此处对应的就是0,对应的值就是

0x0000000000000000000000000000000000000000000000000000000000000000

import sha3
import binascii
def byte32(i):
    return binascii.unhexlify('%064x'%i) #计算时需要进行填充

a=sha3.keccak_256(byte32(0)).hexdigest()
print(a)
#0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563 x

此后a[1],a[2]对应偏移1,2个插槽

然后我们在调用add()函数看,发生了什么

第一步改变了数组a的长度

第二步在a[2]后面的一个插槽写入0x66

0x06 字符串类型

pragma solidity ^0.4.25;

contract TEST{

    string a='whoami';

}

from Crypto.Util.number import *
b=0x77686f616d69
print(long_to_bytes(b))
#b'whoami'
#0xc代表字符串长度 每个字母占2个十六进制位
pragma solidity ^0.4.25;

contract TEST{

    string a='先知社区';

}

from Crypto.Util.number import *
b=0xe58588e79fa5e7a4bee58cba
print(long_to_bytes(b).decode('utf-8'))
#先知社区
#0x18 每个汉字占6个十六进制位
pragma solidity ^0.4.25;

contract TEST{

    string a='Genius only means hard-working all one\'s life.';

}

此时的存储方式和数组类似

from Crypto.Util.number import *
b=0x47656e697573206f6e6c79206d65616e7320686172642d776f726b696e6720616c6c206f6e652773206c6966652e
print(long_to_bytes(b))
#b"Genius only means hard-working all one's life."

思考了一下,比如像下面这样写,调用add函数后会发生什么

pragma solidity ^0.4.25;

contract TEST{
    string a='abcdf';
    function add(){
        a='Genius only means hard-working all one\'s life.'; 
    }
}

0x07 结构体类型

pragma solidity ^0.4.25;

contract TEST{
    struct test{
        bool a;
        uint8 b;
        uint c;
        string d;
    }
    test student=test(true,0x01,0xff,'abcd');

}

依旧按照存储优化原则

  • a,b slot0
  • c slot1
  • d slot2

如果d超出了32字节,那么此时x=x=keccak_256(2)

pragma solidity ^0.4.25;

contract TEST{
    struct test{
        bool a;
        uint8 b;
        uint c;
        string d;
    }
    test[] student;
    function add(){
        student.push(test(true,0x01,0xff,'abcd'));
    }

}

和变长数组存储类似,只不过以结构体长度为一个存储周期改变

0x08 映射类型

pragma solidity ^0.4.25;

contract TEST{
    mapping(address=>uint) blance;
    function add(){
        blance[0xbc6581e11c216B17aDf5192E209a7F95a49e6837]=0x01;
    }
}

计算的规则是这样的,x=keccak_256(key+slot)

  • key代表映射类型的关键字
  • slot代表定义映射类型变量对应的插槽
import sha3
import binascii
def byte32(i):
    return binascii.unhexlify('%064x'%i)
key=0xbc6581e11c216B17aDf5192E209a7F95a49e6837
b=byte32(key)+byte32(0)
a=sha3.keccak_256(b).hexdigest()
print(a)
#21d25f73dd60df1532a052f5f1044cb0f7986a3f609d8674628447c29af248fb
pragma solidity ^0.4.25;

contract TEST{
    mapping(uint8=>string) blance;
    function add(){
        blance[0xb]="Genius only means hard-working all one's life.";
    }
}

import sha3
import binascii
def byte32(i):
    return binascii.unhexlify('%064x'%i)
key=0xb
b=byte32(key)+byte32(0)
a=sha3.keccak_256(b).hexdigest()
print(a)
#9115655cbcdb654012cf1b2f7e5dbf11c9ef14e152a19d5f8ea75a329092d5a6 slot
a=sha3.keccak_256(byte32(slot)).hexdigest()
#3f6f2497fb590e494002b67c712e1fba86767d2906fb8e1ddae48d2b7d91908b

0x09 综合练习

pragma solidity >0.5.0;

contract StorageExample6 {
    uint256 a = 11;
    uint8 b = 12;
    uint128 c = 13;
    bool d = true;
    uint128 e =  14;
    uint256[] public array =  [401,402,403,405,406];

    address owner;
    mapping(address => UserInfo) public users;
    string  str="name value";

    struct UserInfo {
        string name;
        uint8 age;
        uint8 weight;
        uint256[] orders;
        uint64[3] lastLogins;
    }

   constructor()public {
       owner=msg.sender;

       addUser(owner,"admin",17,120);
   }

   function addUser(address user,string memory name,uint8 age,uint8 weight) public {
       require(age>0 && age <100 ,"bad age");

       uint256[] memory orders;
       uint64[3] memory logins;

       users[user] = UserInfo({
           name: name, age:    age,  weight:weight,
           orders:orders,  lastLogins:logins
       });
   }
   function addLog(address user,uint64 id1,uint64 id2,uint64 id3) public{
       UserInfo storage u = users[user];
       assert(u.age>0);

       u.lastLogins[0]=id1;
       u.lastLogins[1]=id2;
       u.lastLogins[2]=id3;
   }

   function addOrder(address user,uint256 orderID) public{
       UserInfo storage u = users[user];
       assert(u.age>0);
       u.orders.push(orderID);
   }
   function getLogins(address user) public view returns (uint64,uint64,uint64){
        UserInfo storage u = users[user];
       return  (u.lastLogins[0],u.lastLogins[1],u.lastLogins[2]);
   }
   function getOrders(address user) public view returns (uint256[] memory){
        UserInfo storage u = users[user];
       return  u.orders;
   }
}

避免太过冗长,放个图

0x10 解题练习

web3.eth.getStorageAt(address, position [, defaultBlock] [, callback])
  • address:String - 要读取的地址
  • position:Number - 存储中的索引编号
  • defaultBlock:Number|String - 可选,使用该参数覆盖 web3.eth.defaultBlock 属性值
  • callback:Function - 可选的回调函数, 其第一个参数为错误对象,第二个参数为结果。

举两个简单的题目

题目一 --Vault

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

contract Vault {
  bool public locked;
  bytes32 private password;

  constructor(bytes32 _password) public {
    locked = true;
    password = _password;
  }

  function unlock(bytes32 _password) public {
    if (password == _password) {
      locked = false;
    }
  }
}

定义为私有变量只能组织其他合约访问,但是无法阻止公开访问

按照其代码,可以知道password的存储位置是1

web3.eth.getStorageAt(contract.address, 1)

直接使用

contract.unlock("A very strong secret password :\)")//密码错误
contract.unlock(web3.utils.hexToBytes('0x412076657279207374726f6e67207365637265742070617373776f7264203a29'))

题目二 --Lock Box

pragma solidity 0.4.24;

import "../CtfFramework.sol";

contract Lockbox1 is CtfFramework{

    uint256 private pin;

    constructor(address _ctfLauncher, address _player) public payable
        CtfFramework(_ctfLauncher, _player)
    {
        pin = now%10000;
    }

    function unlock(uint256 _pin) external ctf{
        require(pin == _pin, "Incorrect PIN");
        msg.sender.transfer(address(this).balance);
    }

}
  • 读取私有变量
  • constructor只在构造的时候执行一次

BY:先知论坛

  • 左青龙
  • 微信扫一扫
  • weinxin
  • 右白虎
  • 微信扫一扫
  • weinxin
admin
  • 本文由 发表于 2021年12月31日14:45:29
  • 转载请保留本文链接(CN-SEC中文网:感谢原作者辛苦付出):
                   智能合约变量储存机制详解 - zpanhttps://cn-sec.com/archives/709516.html

发表评论

匿名网友 填写信息