冷钱包安全与数字资产管理：硬件安全的链上保障

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

import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract ColdWalletVault is AccessControl, ReentrancyGuard {
    bytes32 public constant SIGNER_ROLE = keccak256("SIGNER_ROLE");
    bytes32 public constant GUARDIAN_ROLE = keccak256("GUARDIAN_ROLE");

    enum VaultStatus {
        ACTIVE, FROZEN, RECOVERING, COMPROMISED
    }

    enum TransactionStatus {
        PENDING, APPROVED, EXECUTED, REJECTED, CANCELLED
    }

    struct Vault {
        address owner;
        uint256 requiredSigners;
        uint256 totalSigners;
        uint256 timelock;
        VaultStatus status;
        uint256 lastActivity;
        address[] signers;
    }

    struct VaultTransaction {
        uint256 txId;
        address target;
        uint256 value;
        bytes data;
        string description;
        uint256 approvals;
        uint256 rejections;
        TransactionStatus status;
        uint256 createdAt;
        uint256 executedAt;
        mapping(address => bool) hasApproved;
        mapping(address => bool) hasRejected;
    }

    struct RecoveryPlan {
        address newOwner;
        uint256 recoveryDelay;
        uint256 initiatedAt;
        bool isActive;
        address[] guardians;
        uint256 guardianApprovals;
    }

    mapping(address => Vault) public vaults;
    mapping(uint256 => VaultTransaction) public transactions;
    mapping(address => RecoveryPlan) public recoveryPlans;

    uint256 public transactionCount;
    uint256 public totalVaults;
    uint256 public securityScore;
    uint256 public minTimelock = 1 days;

    event VaultCreated(address indexed owner, uint256 requiredSigners);
    event TransactionProposed(uint256 indexed txId, address indexed proposer, address target);
    event TransactionApproved(uint256 indexed txId, address indexed approver);
    event TransactionExecuted(uint256 indexed txId);
    event RecoveryInitiated(address indexed owner, address newOwner);
    event VaultFrozen(address indexed owner);

    function createVault(
        address[] memory _signers,
        uint256 _requiredSigners,
        uint256 _timelock
    ) external returns (address) {
        require(_signers.length >= _requiredSigners, "Insufficient signers");
        require(_requiredSigners > 0, "Required signers must be > 0");
        require(_timelock >= minTimelock, "Timelock too short");

        totalVaults++;
        Vault storage vault = vaults[msg.sender];
        vault.owner = msg.sender;
        vault.requiredSigners = _requiredSigners;
        vault.totalSigners = _signers.length;
        vault.timelock = _timelock;
        vault.status = VaultStatus.ACTIVE;
        vault.lastActivity = block.timestamp;
        vault.signers = _signers;

        for (uint256 i = 0; i < _signers.length; i++) {
            _grantRole(SIGNER_ROLE, _signers[i]);
        }

        emit VaultCreated(msg.sender, _requiredSigners);
        return msg.sender;
    }

    function proposeTransaction(
        address _target,
        uint256 _value,
        bytes calldata _data,
        string memory _description
    ) external onlyRole(SIGNER_ROLE) returns (uint256) {
        Vault storage vault = vaults[msg.sender];
        require(vault.status == VaultStatus.ACTIVE, "Vault not active");

        transactionCount++;
        VaultTransaction storage tx = transactions[transactionCount];
        tx.txId = transactionCount;
        tx.target = _target;
        tx.value = _value;
        tx.data = _data;
        tx.description = _description;
        tx.approvals = 0;
        tx.rejections = 0;
        tx.status = TransactionStatus.PENDING;
        tx.createdAt = block.timestamp;
        tx.executedAt = 0;

        emit TransactionProposed(transactionCount, msg.sender, _target);
        return transactionCount;
    }

    function approveTransaction(uint256 _txId) external onlyRole(SIGNER_ROLE) {
        VaultTransaction storage tx = transactions[_txId];
        require(tx.status == TransactionStatus.PENDING, "Transaction not pending");
        require(!tx.hasApproved[msg.sender], "Already approved");
        require(!tx.hasRejected[msg.sender], "Already rejected");

        tx.hasApproved[msg.sender] = true;
        tx.approvals++;

        emit TransactionApproved(_txId, msg.sender);

        Vault storage vault = vaults[msg.sender];
        if (tx.approvals >= vault.requiredSigners) {
            tx.status = TransactionStatus.APPROVED;
        }
    }

    function executeTransaction(uint256 _txId) external nonReentrant {
        VaultTransaction storage tx = transactions[_txId];
        require(tx.status == TransactionStatus.APPROVED, "Transaction not approved");

        Vault storage vault = vaults[tx.target != address(0) ? tx.target : msg.sender];
        require(block.timestamp >= tx.createdAt + vault.timelock, "Timelock not expired");

        tx.status = TransactionStatus.EXECUTED;
        tx.executedAt = block.timestamp;

        (bool success, ) = tx.target.call{value: tx.value}(tx.data);
        require(success, "Transaction failed");

        emit TransactionExecuted(_txId);
    }

    function initiateRecovery(address _newOwner) external {
        RecoveryPlan storage plan = recoveryPlans[msg.sender];
        require(!plan.isActive, "Recovery already active");

        plan.newOwner = _newOwner;
        plan.recoveryDelay = 7 days;
        plan.initiatedAt = block.timestamp;
        plan.isActive = true;

        emit RecoveryInitiated(msg.sender, _newOwner);
    }

    function freezeVault() external onlyRole(GUARDIAN_ROLE) {
        Vault storage vault = vaults[msg.sender];
        vault.status = VaultStatus.FROZEN;
        emit VaultFrozen(msg.sender);
    }

    function getSecurityScore(address _vaultOwner) external view returns (uint256) {
        Vault storage vault = vaults[_vaultOwner];
        uint256 score = 0;
        if (vault.requiredSigners > 1) score += 30;
        if (vault.timelock >= 7 days) score += 30;
        if (vault.totalSigners >= 3) score += 20;
        if (vault.status == VaultStatus.ACTIVE) score += 20;
        return score;
    }
}

import hashlib
import json
from typing import Dict, List, Optional, Tuple
from dataclasses import dataclass
from datetime import datetime, timedelta
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.hkdf import HKDF
from cryptography.hazmat.backends import default_backend
import os
import base64

@dataclass
class HardwareWallet:
    model: str
    firmware_version: str
    is_connected: bool
    last_sync: datetime
    security_level: str

class ColdWalletManager:
    def __init__(self):
        self.wallets: Dict[str, HardwareWallet] = {}
        self.vaults: Dict[str, Dict] = {}
        self.transactions: List[Dict] = []
        self.backup_locations: List[str] = []

    def generate_mnemonic(self, word_count: int = 24) -> str:
        entropy = os.urandom(32)
        checksum = hashlib.sha256(entropy).digest()[0]
        entropy_with_checksum = entropy + bytes([checksum])
        mnemonic = base64.b32encode(entropy_with_checksum).decode('utf-8')[:word_count * 4]
        return ' '.join(mnemonic[i:i+4] for i in range(0, len(mnemonic), 4))

    def create_shamir_backup(self, secret: str, shares: int = 3, threshold: int = 2) -> List[str]:
        secret_bytes = secret.encode('utf-8')
        share_length = len(secret_bytes) + 16
        shares_list = []

        for i in range(shares):
            random_bytes = os.urandom(16)
            share = bytes([s ^ r for s, r in zip(secret_bytes, random_bytes * (len(secret_bytes) // 16 + 1))])
            combined = bytes([i]) + random_bytes + share[:len(secret_bytes)]
            shares_list.append(base64.b64encode(combined).decode('utf-8'))

        return shares_list

    def validate_hardware_wallet(self, wallet: HardwareWallet) -> Dict:
        issues = []
        if wallet.firmware_version < '4.0.0':
            issues.append('Firmware too old')
        if not wallet.is_connected:
            issues.append('Wallet not connected')
        if datetime.now() - wallet.last_sync > timedelta(days=30):
            issues.append('Wallet not synced recently')

        return {
            'is_valid': len(issues) == 0,
            'issues': issues,
            'security_level': 'high' if len(issues) == 0 else 'medium' if len(issues) < 2 else 'low'
        }

    def create_vault(self, name: str, signers: List[str], required_signers: int) -> Dict:
        vault = {
            'name': name,
            'signers': signers,
            'required_signers': required_signers,
            'created_at': datetime.now().isoformat(),
            'status': 'active',
            'transactions': [],
            'balance': 0
        }
        vault_id = hashlib.sha256(f"{name}{datetime.now()}".encode()).hexdigest()[:16]
        self.vaults[vault_id] = vault
        return vault

    def propose_transaction(self, vault_id: str, target: str, amount: float, description: str) -> Dict:
        if vault_id not in self.vaults:
            raise ValueError("Vault not found")

        tx = {
            'tx_id': len(self.transactions) + 1,
            'vault_id': vault_id,
            'target': target,
            'amount': amount,
            'description': description,
            'approvals': [],
            'rejections': [],
            'status': 'pending',
            'created_at': datetime.now().isoformat(),
            'timelock': datetime.now() + timedelta(days=1)
        }
        self.transactions.append(tx)
        self.vaults[vault_id]['transactions'].append(tx['tx_id'])
        return tx

    def approve_transaction(self, tx_id: int, signer: str) -> Dict:
        tx = self.transactions[tx_id - 1]
        if signer in tx['approvals']:
            return {'success': False, 'error': 'Already approved'}

        tx['approvals'].append(signer)
        vault = self.vaults[tx['vault_id']]

        if len(tx['approvals']) >= vault['required_signers']:
            tx['status'] = 'approved'

        return {'success': True, 'approvals': len(tx['approvals']), 'required': vault['required_signers']}

    def execute_transaction(self, tx_id: int) -> Dict:
        tx = self.transactions[tx_id - 1]
        if tx['status'] != 'approved':
            return {'success': False, 'error': 'Not approved'}
        if datetime.now() < tx['timelock']:
            return {'success': False, 'error': 'Timelock not expired'}

        tx['status'] = 'executed'
        tx['executed_at'] = datetime.now().isoformat()
        return {'success': True, 'tx_id': tx_id}

    def get_security_checklist(self) -> Dict:
        return {
            'hardware_wallet': {
                'use_hardware_wallet': True,
                'firmware_updated': True,
                'genuine_device': True
            },
            'backup': {
                'mnemonic_backed_up': True,
                'metal_backup': True,
                'distributed_backup': False
            },
            'multisig': {
                'use_multisig': True,
                'required_signers': 2,
                'total_signers': 3
            },
            'timelock': {
                'use_timelock': True,
                'delay_days': 7
            },
            'insurance': {
                'has_insurance': True,
                'coverage_amount': 100000
            }
        }

manager = ColdWalletManager()
mnemonic = manager.generate_mnemonic(24)
shares = manager.create_shamir_backup(mnemonic, 3, 2)
print(f"Mnemonic: {mnemonic[:20]}...")
print(f"Backup shares: {len(shares)}")

const { ethers } = require('ethers');
const crypto = require('crypto');

class ColdWalletSecurity {
  constructor(providerUrl) {
    this.provider = new ethers.providers.JsonRpcProvider(providerUrl);
    this.wallets = new Map();
    this.vaults = new Map();
    this.transactions = [];
    this.backupLocations = [];
  }

  generateMnemonic(strength = 256) {
    const entropy = crypto.randomBytes(strength / 8);
    const hash = crypto.createHash('sha256').update(entropy).digest();
    const entropyWithChecksum = Buffer.concat([entropy, hash.slice(0, 1)]);
    const wordCount = (strength / 32) * 3;
    return entropyWithChecksum.toString('hex').slice(0, wordCount * 5);
  }

  createShamirBackup(secret, shares = 3, threshold = 2) {
    const secretBytes = Buffer.from(secret, 'utf-8');
    const shareLength = secretBytes.length + 16;
    const sharesList = [];

    for (let i = 0; i < shares; i++) {
      const randomBytes = crypto.randomBytes(16);
      const share = Buffer.alloc(secretBytes.length);
      for (let j = 0; j < secretBytes.length; j++) {
        share[j] = secretBytes[j] ^ randomBytes[j % 16];
      }
      const combined = Buffer.concat([
        Buffer.from([i]),
        randomBytes,
        share
      ]);
      sharesList.push(combined.toString('base64'));
    }

    return sharesList;
  }

  async createMultisigVault(signers, requiredSigners, timelockDays) {
    const vaultId = ethers.utils.keccak256(
      ethers.utils.toUtf8Bytes(JSON.stringify({ signers, requiredSigners, timestamp: Date.now() }))
    );

    const vault = {
      id: vaultId,
      signers,
      requiredSigners,
      timelock: timelockDays * 86400,
      balance: ethers.BigNumber.from(0),
      transactions: [],
      created: Math.floor(Date.now() / 1000),
      status: 'active'
    };

    this.vaults.set(vaultId, vault);
    return vault;
  }

  async proposeTransaction(vaultId, target, value, data) {
    const vault = this.vaults.get(vaultId);
    if (!vault) throw new Error('Vault not found');

    const txId = this.transactions.length + 1;
    const tx = {
      id: txId,
      vaultId,
      target,
      value: ethers.BigNumber.from(value),
      data: data || '0x',
      approvals: new Set(),
      rejections: new Set(),
      status: 'pending',
      createdAt: Math.floor(Date.now() / 1000),
      executedAt: null
    };

    this.transactions.push(tx);
    vault.transactions.push(txId);
    return tx;
  }

  async approveTransaction(txId, signer) {
    const tx = this.transactions[txId - 1];
    if (!tx) throw new Error('Transaction not found');

    tx.approvals.add(signer);
    const vault = this.vaults.get(tx.vaultId);

    if (tx.approvals.size >= vault.requiredSigners) {
      tx.status = 'approved';
    }

    return {
      approvals: tx.approvals.size,
      required: vault.requiredSigners,
      status: tx.status
    };
  }

  async executeTransaction(txId) {
    const tx = this.transactions[txId - 1];
    if (!tx) throw new Error('Transaction not found');
    if (tx.status !== 'approved') throw new Error('Not approved');

    const vault = this.vaults.get(tx.vaultId);
    const now = Math.floor(Date.now() / 1000);
    if (now < tx.createdAt + vault.timelock) {
      throw new Error('Timelock not expired');
    }

    tx.status = 'executed';
    tx.executedAt = now;
    return { success: true, txId };
  }

  async validateHardwareWallet(walletInfo) {
    const issues = [];
    if (walletInfo.firmwareVersion < '4.0.0') issues.push('Firmware too old');
    if (!walletInfo.isConnected) issues.push('Wallet not connected');
    if (walletInfo.lastSync < Date.now() - 30 * 86400000) issues.push('Not synced');

    return {
      isValid: issues.length === 0,
      issues,
      securityLevel: issues.length === 0 ? 'high' : issues.length < 2 ? 'medium' : 'low'
    };
  }

  getSecurityChecklist() {
    return {
      hardwareWallet: { recommended: true, implemented: true },
      multisig: { recommended: true, implemented: true },
      timelock: { recommended: true, implemented: true },
      backup: { recommended: true, implemented: true },
      shamirBackup: { recommended: true, implemented: false },
      insurance: { recommended: true, implemented: false },
      regularAudit: { recommended: true, implemented: false }
    };
  }
}

const security = new ColdWalletSecurity('https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY');
const vault = security.createMultisigVault(
  ['0xSigner1', '0xSigner2', '0xSigner3'],
  2,
  7
).then(v => console.log('Vault created:', v.id));