基于Solidity简单存储模式：以太坊能否存加密字符串并向指定地址解密？

Hey there! Let's break down your questions about storing encrypted data on Ethereum with a Solidity simple storage contract, step by step.

1. Can Ethereum store an encrypted "hello world" string in a simple Solidity storage contract? #

Absolutely! Ethereum smart contracts (even basic storage ones) have no issues storing encrypted strings. Here's why: encrypted data is just a sequence of bytes (generated via algorithms like AES, RSA, etc.), and Solidity supports both bytes and string types to hold this kind of data.

Here's a minimal example of a storage contract built for encrypted data:

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

contract EncryptedStringStorage {
    // Using bytes for flexibility—encrypted data often fits better here than string
    bytes private _encryptedData;

    // Store encrypted data (call this from your frontend after encrypting "hello world")
    function storeEncrypted(bytes calldata data) external {
        _encryptedData = data;
    }

    // Retrieve the encrypted data
    function getEncrypted() external view returns (bytes memory) {
        return _encryptedData;
    }
}

You'd encrypt "hello world" off-chain first (e.g., using JavaScript's Web Crypto API or CryptoJS), then pass the encrypted bytes to the storeEncrypted function. The contract doesn't need to know anything about the original plaintext—it just stores the encrypted blob.

2. Can we restrict decryption to a list of allowed addresses? #

Important note: Smart contracts shouldn't handle decryption directly. Decryption requires private keys or secret passphrases, and keeping those on-chain would expose them to everyone (huge security risk). Instead, we split this into two parts:

1. Contract-side access control: Restrict who can retrieve the encrypted data to your allowed address list.
2. Off-chain decryption: Authorized addresses take the encrypted data they retrieve and decrypt it locally using their secret key.

Here's an updated contract with address whitelisting to enforce access:

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

contract RestrictedEncryptedStorage {
    bytes private _encryptedData;
    mapping(address => bool) public allowedAddresses;
    address public owner;

    constructor() {
        owner = msg.sender;
        allowedAddresses[owner] = true; // Add deployer to allowed list by default
    }

    // Owner can add addresses to the allowed list
    function addAllowedAddress(address addr) external onlyOwner {
        allowedAddresses[addr] = true;
    }

    // Owner can remove addresses from the allowed list
    function removeAllowedAddress(address addr) external onlyOwner {
        allowedAddresses[addr] = false;
    }

    // Only owner can store new encrypted data
    function storeEncrypted(bytes calldata data) external onlyOwner {
        _encryptedData = data;
    }

    // Only allowed addresses can retrieve the encrypted data
    function getEncrypted() external view returns (bytes memory) {
        require(allowedAddresses[msg.sender], "You're not authorized to access this data");
        return _encryptedData;
    }

    // Modifier to restrict functions to the owner
    modifier onlyOwner() {
        require(msg.sender == owner, "Only the contract owner can call this");
        _;
    }
}

How this works:

• The contract owner manages the list of addresses allowed to fetch the encrypted data.
• Only those authorized addresses can call getEncrypted to get the encrypted bytes.
• Once they have the encrypted data, they decrypt it locally (using the same key used to encrypt "hello world" initially) with off-chain tools—no sensitive keys ever touch the blockchain.

Quick note on storing encrypted data in transactions #

When you call the storeEncrypted function, the encrypted data is included in the transaction's calldata (the input data of the transaction). Ethereum stores this calldata on-chain, and when the contract writes it to storage, it's permanently saved. Keep in mind:

• Transaction calldata is publicly visible on block explorers, but since it's encrypted, no one can read the original "hello world" without the decryption key.
• Storing data on-chain costs gas—larger encrypted blobs will cost more, so use efficient encryption methods to keep data size down.

内容的提问来源于stack exchange，提问作者scala