智能合约安全审计入门篇 —— 访问私有数据

慢雾科技
更新于 2022-03-25 11:13
阅读 3871

上次我们了解了 solidity 中自带的函数——自毁函数，相信大家多少已经对它有所了解，这次我们将了解如何访问合约中的私有数据（private 数据）。

By：小白@慢雾安全团队

## 背景概述

上次我们了解了 solidity 中自带的函数——[自毁函数](https://learnblockchain.cn/article/3331)，相信大家多少已经对它有所了解，这次我们将了解如何访问合约中的私有数据（private 数据）。

## 前置知识

我们先来了解一下 solidity 中的三种数据存储方式：

### 1. storage（存储）

* storage 中的数据被永久存储。其以键值对的形式存储在 slot 插槽中。
* storage 中的数据会被写在区块链中（因此它们会更改状态），这就是为什么使用存储非常昂贵的原因。
* 占用 256 位插槽的 gas 成本为 20,000 gas。
* 修改 storage 的值将花费 5,000 gas 。
* 清理存储插槽时（即将非零字节设置为零），将退还一定量的 gas 。
* storage 共有 2^256 个插槽，每个插槽 32 个字节数据按声明顺序依次存储，数据将会从每个插槽的右边开始存储，如果相邻变量适合单个 32 字节，然后它们被打包到同一个插槽中否则将会启用新的插槽来存储。

![1.png](https://img.learnblockchain.cn/attachments/2022/04/b7Vwn0mZ62578ffbd83cd.png!/scale/50)

（storage 的存储方式图）

* storage 中的数组的存储方式就比较独特了，首先，solidity 中的数组分为两种：

a.定长数组（长度固定）：

定长数组中的每个元素都会有一个独立的插槽来存储。以一个含有三个 uint64 元素的定长数组为例，下图可以清楚的看出其存储方式：

![2.png](https://img.learnblockchain.cn/attachments/2022/04/ugoIvyRy6257900b85431.png!/scale/50)

（定长数组存储方式图）

b.变长数组（长度随元素的数量而改变）：

变长数组的存储方式就很奇特，在遇到变长数组时，会先启用一个新的插槽 slotA 用来存储数组的长度，其数据存储在另外的编号为 slotV 的插槽中。slotA 表示变长数组声明的位置，用 length 表示变长数组的长度，用 slotV 表示变长数组数据存储的位置，用 value 表示变长数组某个数据的值，用 index 表示 value 对应的索引下标，则

length = sload(slotA)

slotV = keccak256(slotA) + index

value = sload(slotV)

变长数组在编译期间无法知道数组的长度，没办法提前预留存储空间，所以 Solidity 就用 slotA 位置存储了变长数组的长度。

我们写一个简单的例子来验证上面描述的变长数组的存储方式：

```
pragma solidity ^0.8.0;
contract haha{    uint[] user;
  function addUser(uint a) public returns (bytes memory){    user.push(a);    return abi.encode(user);  }}
```

部署这个合约后调用 addUser 函数并传入参数 a = 998，debug 后可以看出变长数组的存储方式：

![3.png](https://img.learnblockchain.cn/attachments/2022/04/lUhg3UuN62579013773d0.png!/scale/60)

其中第一个插槽为（这里存储的是变长数组的长度）：

0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563

这个值等于：

sha3("0x0000000000000000000000000000000000000000000000000000000000000000")

key = 0 这是当前插槽的编号

value = 1 这说明变长数组 user[] 中只有一条数据也就是数组长度为 1 ;

第二个插槽为（这里存储的是变长数组中的数据）：

0x510e4e770828ddbf7f7b00ab00a9f6adaf81c0dc9cc85f1f8249c256942d61d9

这个值等于：

sha3("0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563")

插槽编号为：

key=0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563

这个值等于：

sha3("0x0000000000000000000000000000000000000000000000000000000000000000")+0

插槽中存储的数据为：

value=0x00000000000000000000000000000000000000000000000000000000000003e6

也就是 16 进制表示的 998 ，也就是我们传入的 a 的值。

为了更准确的验证我们再调用一次 addUser 函数并传入 a=999 可以得到下面的结果：

![4.png](https://img.learnblockchain.cn/attachments/2022/04/gKQG7IKi6257901c5e8de.png!/scale/60)

这里我们可以看到新的插槽为：

0x6c13d8c1c5df666ea9ca2a428504a3776c8ca01021c3a1524ca7d765f600979a

这个值等于：

sha3("0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e564")

插槽编号为： key=0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e564

这个值等于：

sha3("0x0000000000000000000000000000000000000000000000000000000000000000")+1

插槽中的存储数据为：

value=0x00000000000000000000000000000000000000000000000000000000000003e7

这个值就是 16 进制表示的 999 也就是我们刚刚调用 addUser 函数传入的 a 的值。

通过上面的例子应该可以大致理解变长数组的存储方式了。

### 2. memory（内存）

* memory 是一个字节数组，其插槽大小为 256 位（32 个字节）。数据仅在函数执行期间存储，执行完之后，将会被删除。它们不会保存到区块链中。
* 读或写一个字节（256 位）需要 3 gas 。
* 为了避免给矿工带来太多工作，在进行 22 次读写操作后，之后的读写成本开始上升。

### 3. calldata（调用数据）

* calldata 是一个不可修改的，非持久性的区域，用于存储函数参数，并且其行为基本上类似于 memory。
* 调用外部函数的参数需要 calldata，也可用于其他变量。
* 它避免了复制，并确保了数据不能被修改。
* 带有 calldata 数据位置的数组和结构体也可以从函数中返回，但是不可以为这种类型赋值。

了解了 solidity 中的三种存储方式后我们再来了解一下合约中的四种可见性关键字：在 solidity 中，有四种可见性关键字：external，public，internal 和 private。默认时函数可见性为 public。对状态变量而言，除了不能用 external 来定义，其它三个都可以来定义变量，状态变量默认的可见性为 internal。

### 1. external 关键字

external 定义的外部函数可以被其它合约调用。用 external 修饰的外部函数 function() 不能作为内部函数直接调用，也就是说 function() 的调用方式必须用 this.function() 。

### 2. public 关键字

public 定义的函数可以被内部函数或外部消息调用。对用 public 定义的状态变量，系统会自动生成一个 getter 函数。

### 3. internal 用关键字

internal 定义的函数和状态变量只能在（当前合约或当前合约派生的合约）内部进行访问。

### 4. private 关键字

private 定义的函数和状态变量只对定义它的合约可见，该合约派生的合约都不能调用和访问该函数及状态变量。

综上可知，合约中修饰变量存储的关键字仅仅限制了其调用的范围，并没有限制其是否可读。所以我们今天就来带大家了解如何读取合约中的所有数据。

## 漏洞示例

这次我们的目标合约是部署在 Ropsten 上的一个合约。

合约地址：

0x3505a02BCDFbb225988161a95528bfDb279faD6b

链接：

https://ropsten.etherscan.io/address/0x3505a02BCDFbb225988161a95528bfDb279faD6b#code

这里我也给大家把合约源码展示出来：

```
contract Vault {    uint public count = 123;    address public owner = msg.sender;    bool public isTrue = true;    uint16 public u16 = 31;    bytes32 private password;    uint public constant someConst = 123;    bytes32[3] public data;
    struct User {        uint id;        bytes32 password;    }    User[] private users;    mapping(uint => User) private idToUser;
    constructor(bytes32 _password) {        password = _password;    }
    function addUser(bytes32 _password) public {        User memory user = User({id: users.length, password: _password});
        users.push(user);        idToUser[user.id] = user;    }
    function getArrayLocation(        uint slot,        uint index,        uint elementSize) public pure returns (uint) {        return uint(keccak256(abi.encodePacked(slot))) + (index * elementSize);    }
    function getMapLocation(uint slot, uint key) public pure returns (uint) {        return uint(keccak256(abi.encodePacked(key, slot)));    }}
```

## 漏洞分析

由上面的合约代码我们可以看到，Vault 合约将用户的用户名和密码这样的敏感数据记录在了合约中，由前置知识中我们可以了解到，合约中修饰变量的关键字仅限制其调用范围，这也就间接证明了合约中的数据均是公开的，可任意读取的，将敏感数据记录在合约中是不安全的。

## 读取数据

下面我们就带大家来读取这个合约中的数据。首先我们先看 slot0 中的数据：

由合约中可以看到 slot0 中只存储了一个 uint 类型的数据，我们读取出来看一下：

我这里使用 Web3.py 取得数据

首先写好程序

![5.png](https://img.learnblockchain.cn/attachments/2022/04/AzqeHw6l62579028d7660.png!/scale/60)

运行后得到

![6.png](https://img.learnblockchain.cn/attachments/2022/04/vRiTJNie6257903003061.png!/scale/60)

我们使用进制转换器转换一下

![7.png](https://img.learnblockchain.cn/attachments/2022/04/toc9lqMx6257903669380.png!/scale/60)

这里我们就成功的去到了合约中的第一个插槽 slot0 中存储的 uint 类型的变量 count=123 ，下面我们继续：

slot1 中存储三个变量：u16, isTrue, owner

![8.png](https://img.learnblockchain.cn/attachments/2022/04/tiS66yDl6257903d64387.png!/scale/60)

![9.png](https://img.learnblockchain.cn/attachments/2022/04/43JO2jHX62579044ec29b.png!/scale/60)

从右往左依次为

owner = f36467c4e023c355026066b8dc51456e7b791d99

isTrue = 01 = true

u16 = 1f = 31

slot2 中就存储着私有变量 password 我们读取看看

![10.png](https://img.learnblockchain.cn/attachments/2022/04/WGabxNJx6257904c5d2ec.png!/scale/60)

![11.png](https://img.learnblockchain.cn/attachments/2022/04/aSSVip4n6257905253f0b.png!/scale/60)

slot 3, 4, 5 中存储着定长数组中的三个元素

![12.png](https://img.learnblockchain.cn/attachments/2022/04/hGMlhTgQ6257905896bb8.png!/scale/60)

![13.png](https://img.learnblockchain.cn/attachments/2022/04/dIqwsZYr6257905e882a4.png!/scale/60)

slot6 中存储着变长数组的长度

![14.png](https://img.learnblockchain.cn/attachments/2022/04/OpaerGiM62579067ef0b6.png!/scale/60)

![15.png](https://img.learnblockchain.cn/attachments/2022/04/hKUVKqpC62579070d64c5.png!/scale/60)

我们从合约代码中可以看到用户的 id 和 password 是由键值对的形式存储的，下面我们来读取两个用户的 id 和 password：

user1

![16.png](https://img.learnblockchain.cn/attachments/2022/04/JLYbqA7X62579078e24c4.png!/scale/60)

![17.png](https://img.learnblockchain.cn/attachments/2022/04/ODZZhKXA62579080ea5f0.png!/scale/60)

user2

![18.png](https://img.learnblockchain.cn/attachments/2022/04/w3xlvJ5S62579089140b3.png!/scale/60)

![19.png](https://img.learnblockchain.cn/attachments/2022/04/9DRsxo9U62579091d644a.png!/scale/60)

好了，这里我们就成功的将合约中的所有数据读取完成，现在大家应该都能得出一个结论：合约中的私有数据也是可以读取的。

## 修复建议

（1）作为开发者

不要将任何敏感数据存放在合约中，因为合约中的任何数据都可被读取。

（2）作为审计者

在审计过程中应当注意合约中是否存在敏感数据，例如：秘钥，游戏通关口令等。

## 参考文献

本期讲解的知识有点偏底层，可以参考以下文章帮助你更好地理解：

* *https://solidity-by-example.org/hacks/accessing-private-data/*
* *《跟我学 Solidity : 变量的存储》https://learnblockchain.cn/article/1759*
* *《快速入门——web3.py》https://web3py.readthedocs.io/*
* *《状态变量、函数的权限》https://blog.csdn.net/liyuechun520/article/details/78408608*

> 本文首发于：https://mp.weixin.qq.com/s/_DV6UaRdA_6pUFXt-EnTtA

By：小白@慢雾安全团队

背景概述

上次我们了解了 solidity 中自带的函数——自毁函数，相信大家多少已经对它有所了解，这次我们将了解如何访问合约中的私有数据（private 数据）。

前置知识

我们先来了解一下 solidity 中的三种数据存储方式：

1. storage（存储）

storage 中的数据被永久存储。其以键值对的形式存储在 slot 插槽中。
storage 中的数据会被写在区块链中（因此它们会更改状态），这就是为什么使用存储非常昂贵的原因。
占用 256 位插槽的 gas 成本为 20,000 gas。
修改 storage 的值将花费 5,000 gas 。
清理存储插槽时（即将非零字节设置为零），将退还一定量的 gas 。
storage 共有 2^256 个插槽，每个插槽 32 个字节数据按声明顺序依次存储，数据将会从每个插槽的右边开始存储，如果相邻变量适合单个 32 字节，然后它们被打包到同一个插槽中否则将会启用新的插槽来存储。

（storage 的存储方式图）

storage 中的数组的存储方式就比较独特了，首先，solidity 中的数组分为两种：

a.定长数组（长度固定）：

定长数组中的每个元素都会有一个独立的插槽来存储。以一个含有三个 uint64 元素的定长数组为例，下图可以清楚的看出其存储方式：

（定长数组存储方式图）

b.变长数组（长度随元素的数量而改变）：

length = sload(slotA)

slotV = keccak256(slotA) + index

value = sload(slotV)

变长数组在编译期间无法知道数组的长度，没办法提前预留存储空间，所以 Solidity 就用 slotA 位置存储了变长数组的长度。

我们写一个简单的例子来验证上面描述的变长数组的存储方式：

pragma solidity ^0.8.0;
contract haha{    uint[] user;
  function addUser(uint a) public returns (bytes memory){    user.push(a);    return abi.encode(user);  }}

部署这个合约后调用 addUser 函数并传入参数 a = 998，debug 后可以看出变长数组的存储方式：

其中第一个插槽为（这里存储的是变长数组的长度）：

0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563

这个值等于：

sha3("0x0000000000000000000000000000000000000000000000000000000000000000")

key = 0 这是当前插槽的编号

value = 1 这说明变长数组 user[] 中只有一条数据也就是数组长度为 1 ;

第二个插槽为（这里存储的是变长数组中的数据）：

0x510e4e770828ddbf7f7b00ab00a9f6adaf81c0dc9cc85f1f8249c256942d61d9

这个值等于：

sha3("0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563")

插槽编号为：

key=0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563

这个值等于：

sha3("0x0000000000000000000000000000000000000000000000000000000000000000")+0

插槽中存储的数据为：

value=0x00000000000000000000000000000000000000000000000000000000000003e6

也就是 16 进制表示的 998 ，也就是我们传入的 a 的值。

为了更准确的验证我们再调用一次 addUser 函数并传入 a=999 可以得到下面的结果：

这里我们可以看到新的插槽为：

0x6c13d8c1c5df666ea9ca2a428504a3776c8ca01021c3a1524ca7d765f600979a

这个值等于：

sha3("0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e564")

插槽编号为： key=0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e564

这个值等于：

sha3("0x0000000000000000000000000000000000000000000000000000000000000000")+1

插槽中的存储数据为：

value=0x00000000000000000000000000000000000000000000000000000000000003e7

这个值就是 16 进制表示的 999 也就是我们刚刚调用 addUser 函数传入的 a 的值。

通过上面的例子应该可以大致理解变长数组的存储方式了。

2. memory（内存）

memory 是一个字节数组，其插槽大小为 256 位（32 个字节）。数据仅在函数执行期间存储，执行完之后，将会被删除。它们不会保存到区块链中。
读或写一个字节（256 位）需要 3 gas 。
为了避免给矿工带来太多工作，在进行 22 次读写操作后，之后的读写成本开始上升。

3. calldata（调用数据）

calldata 是一个不可修改的，非持久性的区域，用于存储函数参数，并且其行为基本上类似于 memory。
调用外部函数的参数需要 calldata，也可用于其他变量。
它避免了复制，并确保了数据不能被修改。
带有 calldata 数据位置的数组和结构体也可以从函数中返回，但是不可以为这种类型赋值。

1. external 关键字

2. public 关键字

public 定义的函数可以被内部函数或外部消息调用。对用 public 定义的状态变量，系统会自动生成一个 getter 函数。

3. internal 用关键字

internal 定义的函数和状态变量只能在（当前合约或当前合约派生的合约）内部进行访问。

4. private 关键字

private 定义的函数和状态变量只对定义它的合约可见，该合约派生的合约都不能调用和访问该函数及状态变量。

漏洞示例

这次我们的目标合约是部署在 Ropsten 上的一个合约。

合约地址：

0x3505a02BCDFbb225988161a95528bfDb279faD6b

链接：

https://ropsten.etherscan.io/address/0x3505a02BCDFbb225988161a95528bfDb279faD6b#code

这里我也给大家把合约源码展示出来：

contract Vault {    uint public count = 123;    address public owner = msg.sender;    bool public isTrue = true;    uint16 public u16 = 31;    bytes32 private password;    uint public constant someConst = 123;    bytes32[3] public data;
    struct User {        uint id;        bytes32 password;    }    User[] private users;    mapping(uint => User) private idToUser;
    constructor(bytes32 _password) {        password = _password;    }
    function addUser(bytes32 _password) public {        User memory user = User({id: users.length, password: _password});
        users.push(user);        idToUser[user.id] = user;    }
    function getArrayLocation(        uint slot,        uint index,        uint elementSize) public pure returns (uint) {        return uint(keccak256(abi.encodePacked(slot))) + (index * elementSize);    }
    function getMapLocation(uint slot, uint key) public pure returns (uint) {        return uint(keccak256(abi.encodePacked(key, slot)));    }}