022_Web3.0私钥生成最佳实践与熵源安全：从硬件RNG到量子时代的密码学保障

私钥安全性公式：攻击难度 = 2^熵量(位)

// Node.js中使用crypto模块生成密码学安全的随机数
const crypto = require('crypto');

// 生成256位(32字节)随机数作为私钥
function generateSecurePrivateKey() {
  // 使用crypto.randomBytes，这是一个CSPRNG实现
  const privateKeyBytes = crypto.randomBytes(32);
  
  // 转换为十六进制字符串
  const privateKeyHex = privateKeyBytes.toString('hex');
  
  console.log(`生成的私钥(十六进制): ${privateKeyHex}`);
  console.log(`私钥长度: ${privateKeyHex.length} 字符`);
  console.log(`熵估计: 至少256位`);
  
  return {
    hex: privateKeyHex,
    bytes: privateKeyBytes
  };
}

// 使用示例
const privateKey = generateSecurePrivateKey();

// 验证私钥格式和熵
function validatePrivateKey(privateKey) {
  const isHex = /^[0-9a-fA-F]{64}$/.test(privateKey.hex);
  const hasSufficientLength = privateKey.bytes.length >= 32;
  
  console.log(`私钥格式验证: ${isHex ? '通过' : '失败'}`);
  console.log(`私钥长度验证: ${hasSufficientLength ? '通过' : '失败'}`);
  
  return isHex && hasSufficientLength;
}

validatePrivateKey(privateKey);

# Python中使用secrets模块生成安全随机数和种子管理
import secrets
import os
import time
import hashlib

class SecureSeedManager:
    def __init__(self, seed_file='secure_seed.dat'):
        self.seed_file = seed_file
        self.entropy_pool = bytearray()
    
    def collect_entropy(self, entropy_sources=None):
        """收集多个熵源的随机数据"""
        # 默认熵源
        if entropy_sources is None:
            entropy_sources = [
                os.urandom(32),  # 系统随机数生成器
                str(time.time()).encode(),  # 当前时间
                os.getpid().to_bytes(4, 'big'),  # 进程ID
                os.getcwd().encode(),  # 当前工作目录
                # 可以添加更多熵源
            ]
        
        # 收集熵
        for source in entropy_sources:
            self.entropy_pool.extend(source)
        
        return len(self.entropy_pool)
    
    def save_seed(self):
        """安全保存种子到文件"""
        # 确保有足够的熵
        if len(self.entropy_pool) < 32:
            self.collect_entropy()
        
        # 生成种子
        seed = hashlib.sha512(self.entropy_pool).digest()[:32]
        
        # 安全写入文件（覆盖写入，减少取证风险）
        with open(self.seed_file, 'wb') as f:
            f.write(seed)
        
        # 设置严格的文件权限（仅所有者可读写）
        os.chmod(self.seed_file, 0o600)
        
        return seed
    
    def generate_from_seed(self, seed=None):
        """从种子生成私钥"""
        if seed is None:
            try:
                with open(self.seed_file, 'rb') as f:
                    seed = f.read(32)
            except FileNotFoundError:
                seed = self.save_seed()
        
        # 使用种子派生私钥（确定性但安全）
        private_key = hashlib.sha256(seed + str(time.time()).encode()).digest()
        
        return private_key.hex()

# 使用示例
seed_manager = SecureSeedManager()
seed_manager.collect_entropy()  # 收集熵
private_key = seed_manager.generate_from_seed()
print(f"从安全种子生成的私钥: {private_key}")

// Node.js与外部HRNG设备交互示例
const SerialPort = require('serialport');
const Readline = require('@serialport/parser-readline');

class HRNGDevice {
  constructor(portName, baudRate = 115200) {
    this.port = new SerialPort(portName, { baudRate });
    this.parser = this.port.pipe(new Readline({ delimiter: '\n' }));
    this.buffer = Buffer.alloc(0);
    this.isReady = false;
    
    this.setupEventListeners();
  }
  
  setupEventListeners() {
    this.port.on('open', () => {
      console.log(`HRNG设备已连接: ${this.port.path}`);
      this.isReady = true;
      // 发送命令请求随机数据
      this.requestRandomData();
    });
    
    this.parser.on('data', (data) => {
      try {
        // 假设数据格式为十六进制字符串
        const randomBytes = Buffer.from(data.trim(), 'hex');
        this.buffer = Buffer.concat([this.buffer, randomBytes]);
        console.log(`从HRNG接收了 ${randomBytes.length} 字节随机数据`);
      } catch (error) {
        console.error('解析HRNG数据失败:', error);
      }
    });
    
    this.port.on('error', (err) => {
      console.error('HRNG设备错误:', err);
      this.isReady = false;
    });
  }
  
  requestRandomData(byteCount = 32) {
    // 发送命令到设备请求指定字节数的随机数据
    // 注意：具体命令格式取决于HRNG设备型号
    this.port.write(`RANDOM:${byteCount}\n`);
  }
  
  async generatePrivateKey() {
    // 确保设备就绪
    if (!this.isReady) {
      throw new Error('HRNG设备未就绪');
    }
    
    // 确保有足够的随机数据
    while (this.buffer.length < 32) {
      this.requestRandomData(32 - this.buffer.length);
      await new Promise(resolve => setTimeout(resolve, 100));
    }
    
    // 提取32字节作为私钥
    const privateKeyBytes = this.buffer.slice(0, 32);
    // 移除已使用的数据
    this.buffer = this.buffer.slice(32);
    
    return {
      hex: privateKeyBytes.toString('hex'),
      bytes: privateKeyBytes
    };
  }
  
  close() {
    this.port.close();
    console.log('HRNG设备连接已关闭');
  }
}

// 使用示例
async function generateHardwareSecuredPrivateKey() {
  try {
    // Windows系统上的COM端口示例
    const hrng = new HRNGDevice('COM3');
    
    // 等待设备初始化
    await new Promise(resolve => setTimeout(resolve, 2000));
    
    // 生成私钥
    const privateKey = await hrng.generatePrivateKey();
    console.log(`使用HRNG生成的私钥: ${privateKey.hex}`);
    
    // 关闭连接
    hrng.close();
    
    return privateKey;
  } catch (error) {
    console.error('HRNG操作失败:', error);
    // 降级到软件CSPRNG作为备选
    return fallbackToSoftwareRNG();
  }
}

function fallbackToSoftwareRNG() {
  console.log('使用软件CSPRNG作为备选');
  const crypto = require('crypto');
  const privateKeyBytes = crypto.randomBytes(32);
  return {
    hex: privateKeyBytes.toString('hex'),
    bytes: privateKeyBytes
  };
}

# Python实现的多源熵聚合器
import secrets
import os
import time
import hashlib
import hmac
import random
import psutil
import platform

class MultiSourceEntropyAggregator:
    def __init__(self, min_entropy_bytes=32):
        self.min_entropy_bytes = min_entropy_bytes
        self.entropy_sources = []
        self.register_default_sources()
    
    def register_default_sources(self):
        """注册默认熵源"""
        self.register_entropy_source(self._system_entropy_source)
        self.register_entropy_source(self._process_entropy_source)
        self.register_entropy_source(self._time_entropy_source)
        self.register_entropy_source(self._hardware_entropy_source)
        self.register_entropy_source(self._user_input_entropy_source)
    
    def register_entropy_source(self, source_function):
        """注册自定义熵源函数"""
        self.entropy_sources.append(source_function)
    
    def _system_entropy_source(self):
        """系统级熵源"""
        data = bytearray()
        
        # 系统信息
        data.extend(platform.platform().encode())
        data.extend(str(os.cpu_count()).encode())
        data.extend(str(os.total_mem()).encode())
        
        # 进程列表信息（采样部分）
        try:
            for proc in psutil.process_iter(['pid', 'name', 'cpu_percent']):
                try:
                    pinfo = proc.info
                    data.extend(str(pinfo).encode())
                except (psutil.NoSuchProcess, psutil.AccessDenied):
                    pass
                if len(data) > 1024:  # 限制大小
                    break
        except ImportError:
            pass
        
        return hashlib.sha256(data).digest()
    
    def _process_entropy_source(self):
        """进程级熵源"""
        data = bytearray()
        
        # 进程信息
        data.extend(str(os.getpid()).encode())
        data.extend(str(os.getppid()).encode())
        data.extend(os.getcwd().encode())
        data.extend(os.getenv('PATH', '').encode())
        
        # 内存地址信息（低精度，不泄露敏感数据）
        random_obj = random.Random()
        data.extend(str(id(random_obj)).encode())
        
        return hashlib.sha256(data).digest()
    
    def _time_entropy_source(self):
        """时间相关熵源"""
        data = bytearray()
        
        # 多种时间度量
        data.extend(str(time.time()).encode())  # 时间戳
        data.extend(str(time.perf_counter()).encode())  # 高精度计时器
        data.extend(str(time.process_time()).encode())  # 进程时间
        data.extend(str(time.time_ns()).encode())  # 纳秒精度
        
        # 时间抖动（执行多次获取微小差异）
        for _ in range(10):
            t1 = time.perf_counter_ns()
            t2 = time.perf_counter_ns()
            data.extend((t2 - t1).to_bytes(8, 'big'))
        
        return hashlib.sha256(data).digest()
    
    def _hardware_entropy_source(self):
        """硬件相关熵源"""
        # 优先使用secrets模块（利用系统CSPRNG）
        return secrets.token_bytes(32)
    
    def _user_input_entropy_source(self):
        """用户输入熵源（如果可用）"""
        data = bytearray()
        try:
            # 非阻塞方式尝试获取用户输入（如果可行）
            # 注意：在某些环境中可能不适用
            import sys
            import select
            
            print("\n请移动鼠标、按下任意键或输入一些随机字符来增加熵（3秒）...")
            
            start_time = time.time()
            while time.time() - start_time < 3:
                if select.select([sys.stdin], [], [], 0)[0]:
                    char = sys.stdin.read(1)
                    data.extend(char.encode())
                    
                # 收集时间抖动作为备选
                data.extend(str(time.time_ns()).encode())
        except:
            # 如果无法获取用户输入，使用额外的系统熵
            data.extend(os.urandom(32))
        
        return hashlib.sha256(data).digest()
    
    def collect_entropy(self):
        """从所有注册的熵源收集熵"""
        collected_entropy = bytearray()
        
        print(f"从 {len(self.entropy_sources)} 个熵源收集随机性...")
        
        for i, source in enumerate(self.entropy_sources):
            try:
                entropy = source()
                collected_entropy.extend(entropy)
                print(f"熵源 {i+1}: 收集了 {len(entropy)} 字节")
            except Exception as e:
                print(f"熵源 {i+1} 失败: {e}")
        
        # 确保收集足够的熵
        if len(collected_entropy) < self.min_entropy_bytes:
            # 补充系统随机数
            补充_entropy = secrets.token_bytes(self.min_entropy_bytes - len(collected_entropy))
            collected_entropy.extend(补充_entropy)
            print(f"补充系统随机数: {len(补充_entropy)} 字节")
        
        return bytes(collected_entropy)
    
    def generate_private_key(self, derivation_salt=None):
        """生成私钥"""
        # 收集熵
        raw_entropy = self.collect_entropy()
        
        # 如果提供了派生盐，使用HMAC增强
        if derivation_salt:
            key_material = hmac.new(derivation_salt, raw_entropy, hashlib.sha512).digest()
        else:
            # 使用SHA-256压缩到256位
            key_material = hashlib.sha256(raw_entropy).digest()
        
        # 确保私钥在secp256k1曲线的有效范围内
        # 注意：在生产环境中，应该进行更严格的验证
        private_key_int = int.from_bytes(key_material, byteorder='big')
        curve_order = int('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141', 16)
        
        if private_key_int >= curve_order:
            # 如果太大，对曲线阶取模
            private_key_int %= curve_order
            # 确保不为零
            if private_key_int == 0:
                private_key_int = 1
        
        # 转换回字节，确保32字节
        private_key_bytes = private_key_int.to_bytes(32, byteorder='big')
        
        return {
            'hex': private_key_bytes.hex(),
            'bytes': private_key_bytes,
            'entropy_sources_count': len(self.entropy_sources)
        }

# 使用示例
if __name__ == "__main__":
    aggregator = MultiSourceEntropyAggregator()
    private_key = aggregator.generate_private_key()
    
    print("\n===== 私钥生成结果 =====")
    print(f"私钥 (十六进制): {private_key['hex']}")
    print(f"私钥长度: {len(private_key['hex'])} 字符")
    print(f"熵源数量: {private_key['entropy_sources_count']}")
    print("======================")

# 简化版随机性测试工具
import numpy as np
from collections import Counter

class RandomnessTester:
    def __init__(self, sample_size=10000):
        self.sample_size = sample_size
    
    def convert_to_bits(self, hex_string):
        """将十六进制字符串转换为位列表"""
        bits = []
        for c in hex_string:
            # 将每个十六进制字符转换为4位二进制
            nibble_bits = bin(int(c, 16))[2:].zfill(4)
            bits.extend([int(bit) for bit in nibble_bits])
        return bits
    
    def frequency_test(self, bits):
        """频率测试：检查1的比例是否接近0.5"""
        ones_count = sum(bits)
        zeros_count = len(bits) - ones_count
        
        # 计算比例
        ones_ratio = ones_count / len(bits)
        
        # 计算卡方统计量
        expected = len(bits) / 2
        chi_square = ((ones_count - expected)**2 / expected) + ((zeros_count - expected)**2 / expected)
        
        # 判断结果
        is_random = 0.45 < ones_ratio < 0.55  # 宽松标准，实际应使用更精确的统计检验
        
        return {
            'test_name': '频率测试',
            'ones_ratio': ones_ratio,
            'chi_square': chi_square,
            'is_random': is_random,
            'result': '通过' if is_random else '失败'
        }
    
    def runs_test(self, bits):
        """游程测试：检查连续相同位的分布"""
        runs = []
        current_bit = bits[0]
        run_length = 1
        
        for bit in bits[1:]:
            if bit == current_bit:
                run_length += 1
            else:
                runs.append(run_length)
                current_bit = bit
                run_length = 1
        runs.append(run_length)  # 添加最后一个游程
        
        # 计算游程分布
        run_counts = Counter(runs)
        
        # 判断是否随机：没有过长的游程
        max_run_length = max(runs)
        expected_max_run = int(np.log2(len(bits))) + 2
        has_normal_runs = max_run_length <= expected_max_run
        
        # 检查游程数量是否在合理范围
        expected_runs = len(bits) / 2 + 0.5
        actual_runs = len(runs)
        runs_ratio = actual_runs / expected_runs
        has_reasonable_run_count = 0.9 < runs_ratio < 1.1
        
        is_random = has_normal_runs and has_reasonable_run_count
        
        return {
            'test_name': '游程测试',
            'max_run_length': max_run_length,
            'expected_max_run': expected_max_run,
            'run_count': actual_runs,
            'expected_run_count': expected_run,
            'run_distribution': dict(run_counts),
            'is_random': is_random,
            'result': '通过' if is_random else '失败'
        }
    
    def serial_test(self, bits, m=2):
        """Serial测试：检查m长度的序列分布"""
        # 创建所有可能的m位序列
        patterns = {format(i, f'0{m}b'): 0 for i in range(2**m)}
        
        # 统计每个模式出现的次数
        for i in range(len(bits) - m + 1):
            pattern = ''.join(map(str, bits[i:i+m]))
            patterns[pattern] += 1
        
        # 计算卡方统计量
        expected = (len(bits) - m + 1) / (2**m)
        chi_square = sum((count - expected)**2 / expected for count in patterns.values())
        
        # 判断结果：卡方值不应过大
        threshold = 2**m * 1.5  # 简化阈值，实际应使用卡方分布表
        is_random = chi_square < threshold
        
        return {
            'test_name': f'Serial测试 (m={m})',
            'chi_square': chi_square,
            'threshold': threshold,
            'pattern_distribution': patterns,
            'is_random': is_random,
            'result': '通过' if is_random else '失败'
        }
    
    def entropy_estimate(self, bits):
        """估计位序列的熵"""
        # 计算一阶熵（基于位频率）
        ones_ratio = sum(bits) / len(bits)
        if ones_ratio == 0 or ones_ratio == 1:
            first_order_entropy = 0
        else:
            first_order_entropy = -
                ones_ratio * np.log2(ones_ratio) -
                (1 - ones_ratio) * np.log2(1 - ones_ratio)
        
        # 理想熵为1 bit/bit
        entropy_ratio = first_order_entropy / 1.0
        
        return {
            'test_name': '熵估计',
            'first_order_entropy_per_bit': first_order_entropy,
            'entropy_ratio': entropy_ratio,
            'is_high_entropy': entropy_ratio > 0.95,
            'result': '高熵' if entropy_ratio > 0.95 else '中等熵' if entropy_ratio > 0.8 else '低熵'
        }
    
    def test_private_key(self, private_key_hex):
        """测试私钥的随机性"""
        # 转换为位序列
        bits = self.convert_to_bits(private_key_hex)
        
        # 如果位序列太短，填充到最小样本大小
        if len(bits) < self.sample_size:
            # 注意：这只是为了测试，实际应用中不应填充私钥
            # 我们可以使用私钥作为种子生成更多位进行测试
            import hashlib
            extended_bits = bits.copy()
            current_seed = private_key_hex
            
            while len(extended_bits) < self.sample_size:
                # 使用HMAC生成更多位
                new_bytes = hashlib.sha256(current_seed.encode()).digest()
                new_bits = []
                for byte in new_bytes:
                    byte_bits = bin(byte)[2:].zfill(8)
                    new_bits.extend([int(bit) for bit in byte_bits])
                
                extended_bits.extend(new_bits)
                current_seed = hashlib.sha256(new_bytes).hexdigest()
            
            bits = extended_bits[:self.sample_size]
        
        # 运行所有测试
        test_results = [
            self.frequency_test(bits),
            self.runs_test(bits),
            self.serial_test(bits, m=2),
            self.serial_test(bits, m=3),
            self.entropy_estimate(bits)
        ]
        
        # 计算总体结果
        passed_tests = sum(1 for test in test_results if test['is_random'] or 'is_high_entropy' in test)
        total_tests = len(test_results)
        overall_score = (passed_tests / total_tests) * 100
        
        return {
            'private_key_hex': private_key_hex,
            'test_results': test_results,
            'passed_tests': passed_tests,
            'total_tests': total_tests,
            'overall_score': overall_score,
            'security_assessment': self._assess_security(overall_score)
        }
    
    def _assess_security(self, score):
        """基于得分评估安全性"""
        if score >= 90:
            return "高安全性 - 随机性测试通过，私钥生成质量优秀"
        elif score >= 70:
            return "中等安全性 - 随机性测试基本通过，建议增强熵源"
        else:
            return "低安全性 - 随机性测试未通过，强烈建议重新生成私钥"

# 使用示例
if __name__ == "__main__":
    tester = RandomnessTester()
    
    # 测试一个示例私钥
    example_private_key = "0x7c852118294e51e653712a81e05800f419141751be58f605c371e15141b007a6"
    
    print(f"测试私钥: {example_private_key}")
    results = tester.test_private_key(example_private_key)
    
    print("\n===== 随机性测试结果 =====")
    for test in results['test_results']:
        print(f"\n{test['test_name']}:")
        print(f"  结果: {test['result']}")
        
        # 打印详细信息
        if test['test_name'] == '频率测试':
            print(f"  1的比例: {test['ones_ratio']:.4f} (理想: 0.5)")
            print(f"  卡方值: {test['chi_square']:.4f}")
        elif test['test_name'] == '游程测试':
            print(f"  最长游程: {test['max_run_length']} (预期最大: {test['expected_max_run']})")
            print(f"  游程数量: {test['run_count']} (预期: {test['expected_run_count']:.2f})")
        elif 'Serial' in test['test_name']:
            print(f"  卡方值: {test['chi_square']:.4f} (阈值: {test['threshold']:.2f})")
        elif test['test_name'] == '熵估计':
            print(f"  每比特熵: {test['first_order_entropy_per_bit']:.4f} (理想: 1.0)")
            print(f"  熵比率: {test['entropy_ratio']:.4f}")
    
    print(f"\n===== 总体评估 =====")
    print(f" 通过测试: {results['passed_tests']}/{results['total_tests']}")
    print(f" 总体得分: {results['overall_score']:.2f}%")
    print(f" 安全评估: {results['security_assessment']}")

// 使用D3.js可视化私钥随机性的HTML页面
const visualizationHtml = `
<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>私钥随机性可视化工具</title>
    <script src="https://d3js.org/d3.v7.min.js"></script>
    <style>
        body {
            font-family: Arial, sans-serif;
            margin: 20px;
            background-color: #f5f5f5;
        }
        .container {
            max-width: 1200px;
            margin: 0 auto;
        }
        h1 {
            color: #333;
            text-align: center;
        }
        .input-section {
            background: white;
            padding: 20px;
            border-radius: 8px;
            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
            margin-bottom: 20px;
        }
        .input-group {
            margin-bottom: 15px;
        }
        label {
            display: block;
            margin-bottom: 5px;
            font-weight: bold;
        }
        input[type="text"] {
            width: 100%;
            padding: 10px;
            font-family: monospace;
            font-size: 14px;
            border: 1px solid #ddd;
            border-radius: 4px;
            box-sizing: border-box;
        }
        button {
            background: #4CAF50;
            color: white;
            border: none;
            padding: 10px 20px;
            border-radius: 4px;
            cursor: pointer;
            font-size: 16px;
        }
        button:hover {
            background: #45a049;
        }
        .visualization-section {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(500px, 1fr));
            gap: 20px;
            margin-top: 20px;
        }
        .chart-container {
            background: white;
            padding: 20px;
            border-radius: 8px;
            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
        }
        .chart-title {
            font-weight: bold;
            text-align: center;
            margin-bottom: 15px;
            font-size: 16px;
        }
        .hex-heatmap {
            display: grid;
            grid-template-columns: repeat(16, 1fr);
            grid-template-rows: repeat(16, 1fr);
            gap: 2px;
            width: 100%;
            max-width: 500px;
            margin: 0 auto;
        }
        .heatmap-cell {
            aspect-ratio: 1;
            border-radius: 2px;
        }
        .bit-spectrogram {
            width: 100%;
            height: 200px;
            overflow-x: auto;
            white-space: nowrap;
        }
        .spectrogram-row {
            height: 20px;
            margin-bottom: 2px;
        }
        .bit {
            width: 2px;
            height: 100%;
            display: inline-block;
        }
        .bit-0 {
            background-color: #f0f0f0;
        }
        .bit-1 {
            background-color: #333;
        }
        .analysis-results {
            background: white;
            padding: 20px;
            border-radius: 8px;
            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
            margin-top: 20px;
        }
        .result-item {
            display: flex;
            justify-content: space-between;
            margin-bottom: 10px;
            padding: 8px;
            background-color: #f9f9f9;
            border-radius: 4px;
        }
        .result-label {
            font-weight: bold;
        }
        .result-value {
            font-family: monospace;
        }
        .score-badge {
            padding: 5px 10px;
            border-radius: 15px;
            font-size: 14px;
            font-weight: bold;
        }
        .score-good {
            background-color: #d4edda;
            color: #155724;
        }
        .score-medium {
            background-color: #fff3cd;
            color: #856404;
        }
        .score-bad {
            background-color: #f8d7da;
            color: #721c24;
        }
    </style>
</head>
<body>
    <div class="container">
        <h1>私钥随机性可视化工具</h1>
        
        <div class="input-section">
            <div class="input-group">
                <label for="privateKey">输入私钥 (十六进制格式，64字符):</label>
                <input type="text" id="privateKey" placeholder="例如: 7c852118294e51e653712a81e05800f419141751be58f605c371e15141b007a6">
            </div>
            <button id="visualizeBtn">可视化分析</button>
        </div>
        
        <div class="visualization-section">
            <div class="chart-container">
                <div class="chart-title">私钥字符频率热力图</div>
                <div id="hexHeatmap" class="hex-heatmap"></div>
            </div>
            
            <div class="chart-container">
                <div class="chart-title">私钥位模式可视化 (前10行)</div>
                <div id="bitSpectrogram" class="bit-spectrogram"></div>
            </div>
        </div>
        
        <div class="analysis-results">
            <h2>分析结果</h2>
            <div class="result-item">
                <span class="result-label">1的比例:</span>
                <span class="result-value"><span id="onesRatio">--</span> (理想: 0.5)</span>
            </div>
            <div class="result-item">
                <span class="result-label">熵估计:</span>
                <span class="result-value"><span id="entropyEstimate">--</span> bits/bit (理想: 1.0)</span>
            </div>
            <div class="result-item">
                <span class="result-label">字符分布均匀性:</span>
                <span class="result-value"><span id="distributionScore">--</span>%</span>
            </div>
            <div class="result-item">
                <span class="result-label">随机性评分:</span>
                <span class="score-badge" id="randomnessScore">--</span>
            </div>
            <div class="result-item">
                <span class="result-label">安全评估:</span>
                <span class="result-value" id="securityAssessment">--</span>
            </div>
        </div>
    </div>
    
    <script>
        document.getElementById('visualizeBtn').addEventListener('click', function() {
            const privateKey = document.getElementById('privateKey').value.trim();
            
            // 验证输入
            if (!privateKey || !/^[0-9a-fA-F]{64}$/.test(privateKey)) {
                alert('请输入有效的64字符十六进制私钥!');
                return;
            }
            
            // 分析并可视化私钥
            analyzeAndVisualize(privateKey.toLowerCase());
        });
        
        function analyzeAndVisualize(privateKey) {
            // 1. 转换为位序列
            const bits = hexToBits(privateKey);
            
            // 2. 生成热力图
            generateHexHeatmap(privateKey);
            
            // 3. 生成位谱图
            generateBitSpectrogram(bits);
            
            // 4. 执行分析
            const analysis = analyzeRandomness(privateKey, bits);
            
            // 5. 显示结果
            displayResults(analysis);
        }
        
        function hexToBits(hex) {
            const bits = [];
            for (let i = 0; i < hex.length; i++) {
                const nibble = parseInt(hex[i], 16);
                for (let j = 3; j >= 0; j--) {
                    bits.push((nibble >> j) & 1);
                }
            }
            return bits;
        }
        
        function generateHexHeatmap(hex) {
            const heatmap = document.getElementById('hexHeatmap');
            heatmap.innerHTML = '';
            
            // 计算字符频率
            const frequency = {};
            for (let i = 0; i < hex.length; i++) {
                frequency[hex[i]] = (frequency[hex[i]] || 0) + 1;
            }
            
            // 生成热力图单元格
            const hexChars = '0123456789abcdef';
            const maxFreq = Math.max(...Object.values(frequency));
            
            for (let i = 0; i < 256; i++) {
                const char = hexChars[i % 16];
                const count = frequency[char] || 0;
                const intensity = count / maxFreq;
                
                const cell = document.createElement('div');
                cell.className = 'heatmap-cell';
                cell.title = `${char}: ${count}次`;
                
                // 使用颜色渐变表示频率
                const hue = 200 + intensity * 160; // 从蓝绿色到红色
                cell.style.backgroundColor = `hsl(${hue}, 80%, ${50 + intensity * 30}%)`;
                
                heatmap.appendChild(cell);
            }
        }
        
        function generateBitSpectrogram(bits) {
            const spectrogram = document.getElementById('bitSpectrogram');
            spectrogram.innerHTML = '';
            
            // 生成10行位可视化
            const bitsPerRow = 256;
            const numRows = Math.min(10, Math.ceil(bits.length / bitsPerRow));
            
            for (let row = 0; row < numRows; row++) {
                const rowElement = document.createElement('div');
                rowElement.className = 'spectrogram-row';
                
                const startIdx = row * bitsPerRow;
                const endIdx = Math.min(startIdx + bitsPerRow, bits.length);
                
                for (let i = startIdx; i < endIdx; i++) {
                    const bitElement = document.createElement('div');
                    bitElement.className = `bit bit-${bits[i]}`;
                    rowElement.appendChild(bitElement);
                }
                
                spectrogram.appendChild(rowElement);
            }
        }
        
        function analyzeRandomness(hex, bits) {
            // 计算1的比例
            const onesCount = bits.filter(bit => bit === 1).length;
            const onesRatio = onesCount / bits.length;
            
            // 估算熵
            // 使用字符分布计算香农熵
            const charFrequency = {};
            for (let i = 0; i < hex.length; i++) {
                charFrequency[hex[i]] = (charFrequency[hex[i]] || 0) + 1;
            }
            
            let entropy = 0;
            const totalChars = hex.length;
            for (const char in charFrequency) {
                const probability = charFrequency[char] / totalChars;
                entropy -= probability * Math.log2(probability);
            }
            
            // 计算分布均匀性
            const expectedFrequency = totalChars / 16; // 16个十六进制字符
            let chiSquare = 0;
            for (let i = 0; i < 16; i++) {
                const char = i.toString(16);
                const observed = charFrequency[char] || 0;
                chiSquare += Math.pow(observed - expectedFrequency, 2) / expectedFrequency;
            }
            
            // 归一化均匀性分数 (0-100%)
            const distributionScore = Math.max(0, 100 - (chiSquare / 20) * 100);
            
            // 计算总体随机性评分
            const onesRatioScore = Math.max(0, 100 - Math.abs(onesRatio - 0.5) * 200);
            const entropyScore = Math.min(100, entropy * 20); // 最大熵约为4位/字符
            const overallScore = (onesRatioScore + distributionScore + entropyScore) / 3;
            
            // 安全评估
            let securityAssessment = '';
            if (overallScore >= 90) {
                securityAssessment = '高安全性 - 随机性模式理想，私钥生成质量优秀';
            } else if (overallScore >= 70) {
                securityAssessment = '中等安全性 - 随机性模式可接受，但有改进空间';
            } else {
                securityAssessment = '低安全性 - 随机性模式不理想，建议检查熵源并重新生成';
            }
            
            return {
                onesRatio: onesRatio.toFixed(4),
                entropy: entropy.toFixed(4),
                distributionScore: distributionScore.toFixed(1),
                overallScore: Math.round(overallScore),
                securityAssessment
            };
        }
        
        function displayResults(analysis) {
            document.getElementById('onesRatio').textContent = analysis.onesRatio;
            document.getElementById('entropyEstimate').textContent = analysis.entropy;
            document.getElementById('distributionScore').textContent = analysis.distributionScore;
            
            const scoreBadge = document.getElementById('randomnessScore');
            scoreBadge.textContent = analysis.overallScore + '/100';
            
            // 设置评分徽章样式
            if (analysis.overallScore >= 90) {
                scoreBadge.className = 'score-badge score-good';
            } else if (analysis.overallScore >= 70) {
                scoreBadge.className = 'score-badge score-medium';
            } else {
                scoreBadge.className = 'score-badge score-bad';
            }
            
            document.getElementById('securityAssessment').textContent = analysis.securityAssessment;
        }
    </script>
</body>
</html>
`;

// 将可视化工具保存为HTML文件
const fs = require('fs');
fs.writeFileSync('private_key_visualizer.html', visualizationHtml);
console.log('私钥可视化工具已保存为 private_key_visualizer.html');

# 量子熵源集成示例（模拟）
class QuantumEntropySource:
    def __init__(self, connection_string=None):
        self.connection_string = connection_string
        self.is_connected = False
        self.initialize()
    
    def initialize(self):
        """初始化量子熵源连接"""
        try:
            # 在实际应用中，这里会连接到物理QRNG设备
            # 此处模拟连接过程
            print("正在初始化量子熵源...")
            # 模拟连接延迟
            import time
            time.sleep(1)
            self.is_connected = True
            print("量子熵源连接成功")
        except Exception as e:
            print(f"量子熵源初始化失败: {e}")
            print("降级到软件熵源作为备选")
            self.is_connected = False
    
    def get_random_bytes(self, num_bytes):
        """从量子熵源获取随机字节"""
        if not self.is_connected:
            # 降级到软件熵源
            import secrets
            print("使用软件熵源作为备选")
            return secrets.token_bytes(num_bytes)
        
        try:
            # 模拟从QRNG获取数据
            # 实际应用中，这里会调用设备API
            import os
            # 为模拟目的，使用系统熵但添加标记
            random_bytes = bytearray()
            
            # 模拟量子随机性特征
            for _ in range(num_bytes):
                # 添加一些额外的随机性处理
                # 注意：这只是模拟，不是真正的量子随机性
                import hashlib
                temp = hashlib.sha256(os.urandom(32)).digest()
                random_bytes.append(temp[0])
            
            print(f"从量子熵源获取了 {num_bytes} 字节随机数据")
            return bytes(random_bytes)
        except Exception as e:
            print(f"获取量子随机数据失败: {e}")
            # 降级到软件熵源
            import secrets
            return secrets.token_bytes(num_bytes)
    
    def generate_quantum_private_key(self):
        """生成基于量子熵的私钥"""
        print("使用量子熵生成私钥...")
        
        # 获取32字节量子随机数据
        private_key_bytes = self.get_random_bytes(32)
        
        # 应用后处理以增强安全性
        # 实际应用中，可能会使用级联哈希或其他后处理方法
        import hashlib
        processed_key = hashlib.sha256(private_key_bytes).digest()
        
        # 验证私钥在有效范围内
        # 对于secp256k1曲线
        curve_order = int('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141', 16)
        key_int = int.from_bytes(processed_key, byteorder='big')
        
        # 确保私钥在有效范围内且非零
        if key_int >= curve_order or key_int == 0:
            key_int = key_int % curve_order
            if key_int == 0:
                key_int = 1
            processed_key = key_int.to_bytes(32, byteorder='big')
        
        print("量子私钥生成完成")
        return {
            'hex': processed_key.hex(),
            'bytes': processed_key,
            'source': 'quantum' if self.is_connected else 'software_fallback',
            'timestamp': time.time()
        }
    
    def close(self):
        """关闭量子熵源连接"""
        if self.is_connected:
            print("关闭量子熵源连接...")
            # 实际应用中，这里会关闭设备连接
            self.is_connected = False

# 使用示例
import time
def demonstrate_quantum_key_generation():
    # 创建量子熵源实例
    qrng = QuantumEntropySource()
    
    try:
        # 生成多个私钥并验证它们的唯一性
        private_keys = set()
        num_keys = 10
        
        print(f"\n生成 {num_keys} 个量子私钥并验证唯一性...")
        
        start_time = time.time()
        for i in range(num_keys):
            key = qrng.generate_quantum_private_key()
            private_keys.add(key['hex'])
            print(f"私钥 {i+1}: {key['hex']} (来源: {key['source']})")
        end_time = time.time()
        
        # 验证所有私钥都是唯一的
        all_unique = len(private_keys) == num_keys
        print(f"\n唯一性验证: {'通过' if all_unique else '失败'}")
        print(f"生成速度: {(end_time - start_time) / num_keys:.4f} 秒/私钥")
        
        # 生成一个最终的私钥用于演示
        final_key = qrng.generate_quantum_private_key()
        print(f"\n最终量子私钥: 0x{final_key['hex']}")
        print(f"私钥来源: {final_key['source']}")
        print(f"时间戳: {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(final_key['timestamp']))}")
        
    finally:
        # 关闭连接
        qrng.close()

# 运行演示
demonstrate_quantum_key_generation()

# 简化的基于格的私钥生成示例
# 注意：这只是教育示例，不是生产级实现
import numpy as np
from cryptography.hazmat.primitives import hashes

class LatticePrivateKeyGenerator:
    def __init__(self, n=256, q=8192):
        self.n = n  # 格维度
        self.q = q  # 模数
        self.σ = 3.2  # 高斯分布参数
    
    def generate_keys(self):
        """生成基于格的密钥对"""
        print(f"生成维度为 {self.n} 的格密码私钥...")
        
        # 1. 生成随机矩阵 A (公钥组件)
        A = np.random.randint(0, self.q, (self.n, self.n), dtype=np.int32)
        
        # 2. 生成随机小矩阵 S (私钥)
        S = self._sample_gaussian(self.n, self.n)
        
        # 3. 生成误差矩阵 E
        E = self._sample_gaussian(self.n, self.n)
        
        # 4. 计算 B = A*S + E mod q (公钥组件)
        B = (A @ S + E) % self.q
        
        # 5. 从私钥矩阵生成最终私钥字节
        private_key_bytes = self._matrix_to_bytes(S)
        
        # 6. 使用哈希确保固定长度
        digest = hashes.Hash(hashes.SHA256())
        digest.update(private_key_bytes)
        final_private_key = digest.finalize()
        
        print("格密码私钥生成完成")
        return {
            'hex': final_private_key.hex(),
            'bytes': final_private_key,
            'lattice_dimension': self.n,
            'modulus': self.q
        }
    
    def _sample_gaussian(self, rows, cols):
        """采样高斯分布的小整数"""
        # 使用正态分布，然后截断到小值范围
        samples = np.random.normal(0, self.σ, (rows, cols))
        return np.round(samples).astype(np.int32)
    
    def _matrix_to_bytes(self, matrix):
        """将矩阵转换为字节数组"""
        # 展平矩阵并转换为字节
        flat = matrix.flatten()
        # 将整数转换为有符号字节表示
        bytes_data = bytearray()
        for num in flat:
            # 确保在-128到127范围内
            clamped = max(-128, min(127, num))
            bytes_data.append(clamped & 0xFF)
        return bytes(bytes_data)

# 使用示例
def demonstrate_lattice_key_generation():
    # 创建格密码私钥生成器
    # 注意：实际应用中应使用标准参数
    generator = LatticePrivateKeyGenerator(n=64, q=4096)  # 较小维度用于演示
    
    # 生成私钥
    private_key = generator.generate_keys()
    
    print(f"\n基于格的私钥: 0x{private_key['hex']}")
    print(f"格维度: {private_key['lattice_dimension']}")
    print(f"模数: {private_key['modulus']}")
    print("抗量子特性: 基于格的密码学对Shor算法免疫")

# 运行演示
demonstrate_lattice_key_generation()

# XMSS (eXtended Merkle Signature Scheme) 私钥生成示例
# XMSS是一种基于哈希的数字签名方案，被认为是抗量子的
import hashlib
import os

class XMSSPrivateKeyGenerator:
    def __init__(self, height=10, hash_func=hashlib.sha256):
        self.height = height  # 树高度，决定签名数量 (2^height)
        self.hash_func = hash_func
        self.n = hash_func().digest_size  # 哈希输出大小
    
    def generate_key_pair(self):
        """生成XMSS密钥对"""
        print(f"生成高度为 {self.height} 的XMSS密钥对...")
        
        # 1. 生成种子
        sk_seed = os.urandom(self.n)
        sk_prf = os.urandom(self.n)
        pk_seed = os.urandom(self.n)
        
        # 2. 生成WOTS+密钥对（简化版）
        wots_sk = [os.urandom(self.n) for _ in range(self._wots_len())]
        
        # 3. 构建Merkle树（简化表示）
        merkle_root = self._build_merkle_root(wots_sk, pk_seed)
        
        # 4. 从私钥材料生成最终私钥
        combined_seed = sk_seed + sk_prf + pk_seed
        digest = self.hash_func(combined_seed).digest()
        
        print("XMSS密钥对生成完成")
        return {
            'private_key': {
                'hex': digest.hex(),
                'bytes': digest,
                'sk_seed': sk_seed.hex(),
                'sk_prf': sk_prf.hex()
            },
            'public_key': {
                'merkle_root': merkle_root.hex(),
                'pk_seed': pk_seed.hex()
            },
            'height': self.height,
            'max_signatures': 2 ** self.height
        }
    
    def _wots_len(self):
        """计算WOTS+密钥长度"""
        # 简化计算
        return self.n * 2
    
    def _build_merkle_root(self, wots_sk, pk_seed):
        """简化的Merkle根计算"""
        # 实际应用中，这里会构建完整的Merkle树
        # 此处使用简化版本
        combined = b''.join(wots_sk) + pk_seed
        return self.hash_func(combined).digest()

# 使用示例
def demonstrate_xmss_key_generation():
    # 创建XMSS私钥生成器
    # 注意：实际应用中应使用标准参数
    generator = XMSSPrivateKeyGenerator(height=8)  # 256个签名容量
    
    # 生成密钥对
    keys = generator.generate_key_pair()
    
    print(f"\nXMSS私钥: 0x{keys['private_key']['hex']}")
    print(f"公钥根: 0x{keys['public_key']['merkle_root'][:16]}...")
    print(f"树高度: {keys['height']}")
    print(f"最大签名数量: {keys['max_signatures']}")
    print("抗量子特性: 基于哈希函数的单向性，对量子攻击有抵抗力")

# 运行演示
demonstrate_xmss_key_generation()

安全环境准备 → 多人见证 → 多源熵收集 → 硬件RNG生成 → 离线存储 → 分割备份 → 定期轮换

// 私钥生成安全工作流集成示例
const crypto = require('crypto');
const fs = require('fs');
const path = require('path');
const readline = require('readline');

class SecureKeyGenerationWorkflow {
  constructor(options = {}) {
    this.options = {
      outputDir: './secure_keys',
      enableHardwareRNG: true,
      entropySources: ['system', 'time', 'user', 'hardware'],
      verificationRounds: 3,
      ...options
    };
    
    // 确保输出目录存在
    if (!fs.existsSync(this.options.outputDir)) {
      fs.mkdirSync(this.options.outputDir, { recursive: true });
      console.log(`创建输出目录: ${this.options.outputDir}`);
    }
    
    this.rl = readline.createInterface({
      input: process.stdin,
      output: process.stdout
    });
  }
  
  async start() {
    console.log('\n===== 安全私钥生成工作流 =====');
    console.log('此工具将指导您完成高安全性私钥的生成过程');
    
    // 1. 环境安全检查
    await this.environmentCheck();
    
    // 2. 熵源选择
    await this.configureEntropySources();
    
    // 3. 收集熵
    console.log('\n[3/7] 收集随机熵...');
    const entropyData = await this.collectEntropy();
    
    // 4. 生成私钥
    console.log('\n[4/7] 生成私钥...');
    const privateKey = this.generatePrivateKey(entropyData);
    
    // 5. 验证随机性
    console.log('\n[5/7] 验证私钥随机性...');
    const verification = this.verifyRandomness(privateKey);
    
    // 6. 安全存储
    console.log('\n[6/7] 安全存储私钥...');
    const storageInfo = await this.secureStorage(privateKey);
    
    // 7. 总结报告
    console.log('\n[7/7] 生成总结报告...');
    this.generateReport(privateKey, verification, storageInfo);
    
    console.log('\n===== 私钥生成工作流完成 =====');
    this.rl.close();
  }
  
  async environmentCheck() {
    console.log('\n[1/7] 环境安全检查...');
    
    // 模拟环境检查
    console.log('✓ 检查基础加密库可用性');
    
    // 检查是否为真实系统（非虚拟机）
    // 注意：这只是示例，实际检测更复杂
    console.log('⚠ 虚拟机检测: 建议在物理设备上生成私钥');
    
    // 检查网络连接
    // 实际应用中应检测并建议断开网络
    console.log('⚠ 网络连接检测: 强烈建议在断网环境下生成私钥');
    
    const answer = await this.askQuestion('环境检查完成，是否继续？(y/n): ');
    if (answer.toLowerCase() !== 'y') {
      console.log('操作已取消');
      process.exit(0);
    }
  }
  
  async configureEntropySources() {
    console.log('\n[2/7] 配置熵源...');
    
    console.log('可用熵源:');
    console.log('1. 系统随机数生成器 (CSPRNG)');
    console.log('2. 时间抖动和系统状态');
    console.log('3. 用户交互随机性');
    console.log('4. 硬件随机数生成器 (HRNG)');
    
    // 此处可以根据用户选择配置熵源
    console.log('已选择默认熵源组合');
  }
  
  async collectEntropy() {
    const entropyData = [];
    
    // 1. 系统CSPRNG
    if (this.options.entropySources.includes('system')) {
      const systemEntropy = crypto.randomBytes(64);
      entropyData.push(systemEntropy);
      console.log('✓ 收集系统CSPRNG熵');
    }
    
    // 2. 时间抖动
    if (this.options.entropySources.includes('time')) {
      const timeEntropy = this.collectTimeEntropy();
      entropyData.push(timeEntropy);
      console.log('✓ 收集时间抖动熵');
    }
    
    // 3. 用户交互
    if (this.options.entropySources.includes('user')) {
      const userEntropy = await this.collectUserEntropy();
      entropyData.push(userEntropy);
      console.log('✓ 收集用户交互熵');
    }
    
    // 4. 硬件RNG（模拟）
    if (this.options.entropySources.includes('hardware') && this.options.enableHardwareRNG) {
      try {
        const hardwareEntropy = this.simulateHardwareRNG();
        entropyData.push(hardwareEntropy);
        console.log('✓ 收集硬件RNG熵');
      } catch (error) {
        console.log('✗ 硬件RNG不可用，使用系统CSPRNG作为备选');
        entropyData.push(crypto.randomBytes(32));
      }
    }
    
    // 合并所有熵
    return Buffer.concat(entropyData);
  }
  
  collectTimeEntropy() {
    const timeData = [];
    
    // 收集多次时间戳和性能计数器的微小差异
    for (let i = 0; i < 1000; i++) {
      const start = process.hrtime.bigint();
      // 执行一些计算以增加随机性
      crypto.randomBytes(1);
      const end = process.hrtime.bigint();
      const diff = end - start;
      
      // 将差异添加到时间数据中
      timeData.push(Buffer.from(diff.toString()));
    }
    
    return crypto.createHash('sha512').update(Buffer.concat(timeData)).digest();
  }
  
  async collectUserEntropy() {
    console.log('请移动鼠标、按下键盘或输入随机字符（输入完成后按Enter）...');
    
    const userInput = await this.askQuestion('输入随机字符串: ');
    
    // 收集按键时间信息
    const keyTimings = [];
    let lastTime = process.hrtime.bigint();
    
    for (let i = 0; i < userInput.length; i++) {
      // 模拟按键时间收集
      // 实际应用中应在按键事件中收集
      const currentTime = process.hrtime.bigint();
      const timing = currentTime - lastTime;
      keyTimings.push(timing.toString());
      lastTime = currentTime;
    }
    
    // 合并用户输入和时间信息
    const combinedData = userInput + keyTimings.join(',');
    return crypto.createHash('sha512').update(combinedData).digest();
  }
  
  simulateHardwareRNG() {
    // 模拟硬件RNG
    // 实际应用中应连接物理HRNG设备
    console.log('模拟硬件RNG...');
    return crypto.randomBytes(32);
  }
  
  generatePrivateKey(entropyData) {
    // 使用所有熵数据生成私钥
    const privateKey = crypto.createHash('sha256').update(entropyData).digest();
    
    // 确保私钥在有效范围内（针对secp256k1）
    const keyInt = BigInt('0x' + privateKey.toString('hex'));
    const curveOrder = BigInt('0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141');
    
    let validKey = keyInt;
    if (validKey >= curveOrder || validKey === BigInt(0)) {
      validKey = validKey % curveOrder;
      if (validKey === BigInt(0)) {
        validKey = BigInt(1);
      }
    }
    
    // 转换回32字节的Buffer
    const validKeyHex = validKey.toString(16).padStart(64, '0');
    
    return {
      hex: validKeyHex,
      bytes: Buffer.from(validKeyHex, 'hex')
    };
  }
  
  verifyRandomness(privateKey) {
    const results = {};
    
    // 1. 检查长度
    results.lengthValid = privateKey.bytes.length === 32;
    
    // 2. 检查格式
    results.formatValid = /^[0-9a-fA-F]{64}$/.test(privateKey.hex);
    
    // 3. 基本随机性检查
    const onesCount = this.countOnes(privateKey.bytes);
    const totalBits = privateKey.bytes.length * 8;
    const onesRatio = onesCount / totalBits;
    results.onesRatio = onesRatio;
    results.balancedBits = 0.45 < onesRatio && onesRatio < 0.55;
    
    // 4. 运行多次验证
    results.verificationRounds = [];
    for (let i = 0; i < this.options.verificationRounds; i++) {
      // 生成新的随机密钥进行比对
      const testKey = this.generatePrivateKey(crypto.randomBytes(128));
      // 确保不同
      results.verificationRounds.push(testKey.hex !== privateKey.hex);
    }
    
    // 综合评估
    results.isValid = results.lengthValid && 
                     results.formatValid && 
                     results.balancedBits && 
                     results.verificationRounds.every(Boolean);
    
    return results;
  }
  
  countOnes(buffer) {
    let count = 0;
    for (let i = 0; i < buffer.length; i++) {
      let byte = buffer[i];
      for (let j = 0; j < 8; j++) {
        count += (byte >> j) & 1;
      }
    }
    return count;
  }
  
  async secureStorage(privateKey) {
    // 询问用户如何存储
    console.log('\n选择私钥存储方式:');
    console.log('1. 导出为加密文件（不推荐用于生产环境）');
    console.log('2. 仅显示，手动记录（推荐）');
    
    const choice = await this.askQuestion('请选择 (1/2): ');
    
    const storageInfo = {
      method: choice === '1' ? 'encrypted_file' : 'manual_record',
      timestamp: new Date().toISOString()
    };
    
    if (choice === '1') {
      // 模拟导出加密文件
      const password = await this.askPassword('设置加密密码: ');
      // 在实际应用中，应该使用强加密
      const encryptedData = privateKey.hex; // 简化示例，实际应加密
      const fileName = `private_key_${Date.now()}.enc`;
      const filePath = path.join(this.options.outputDir, fileName);
      
      fs.writeFileSync(filePath, encryptedData);
      storageInfo.filePath = filePath;
      console.log(`私钥已导出到: ${filePath}`);
      console.log('警告: 此为示例，实际应用必须使用强加密！');
    } else {
      // 显示私钥让用户手动记录
      console.log('\n=============================================');
      console.log(`私钥: 0x${privateKey.hex}`);
      console.log('=============================================');
      console.log('请立即将私钥安全记录并离线存储！');
      console.log('私钥显示后将不会再次显示');
      
      await this.askQuestion('确认已记录私钥 (输入任意内容继续): ');
    }
    
    return storageInfo;
  }
  
  generateReport(privateKey, verification, storageInfo) {
    const report = {
      generationTime: new Date().toISOString(),
      privateKeyFingerprint: crypto.createHash('sha256')
        .update(privateKey.hex)
        .digest('hex').substring(0, 16),
      verification,
      storageInfo,
      entropySources: this.options.entropySources,
      securityRecommendations: this.getSecurityRecommendations(verification)
    };
    
    const reportPath = path.join(this.options.outputDir, `key_generation_report_${Date.now()}.json`);
    fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
    
    console.log(`\n报告已保存至: ${reportPath}`);
    console.log('安全建议:');
    report.securityRecommendations.forEach(rec => console.log(`- ${rec}`));
    
    return report;
  }
  
  getSecurityRecommendations(verification) {
    const recommendations = [];
    
    if (!verification.balancedBits) {
      recommendations.push('私钥位分布不够均衡，建议使用更多熵源重新生成');
    }
    
    recommendations.push('使用硬件钱包存储私钥，如Ledger或Trezor');
    recommendations.push('考虑使用BIP-39助记词进行备份');
    recommendations.push('定期验证私钥备份的可用性');
    recommendations.push('永远不要在数字设备或云存储中存储原始私钥');
    
    return recommendations;
  }
  
  askQuestion(question) {
    return new Promise((resolve) => {
      this.rl.question(question, (answer) => {
        resolve(answer);
      });
    });
  }
  
  askPassword(question) {
    return new Promise((resolve) => {
      this.rl.question(question, (password) => {
        // 在实际应用中，应该隐藏输入
        console.log('密码已设置（出于演示目的未隐藏）');
        resolve(password);
      });
    });
  }
}

// 使用示例
console.log('安全私钥生成工具初始化...');
const workflow = new SecureKeyGenerationWorkflow();

// 启动工作流
workflow.start().catch(error => {
  console.error('工作流执行失败:', error);
  workflow.rl.close();
});