区块链基础

一、为什么需要区块链？—— 传统系统的四大痛点与区块链解法

痛点	传统系统问题	区块链解决方案	类比
单点故障	银行服务器宕机导致支付中断	分布式节点网络（7×24 小时运行）	多个备用水库 vs 单个大坝
数据篡改	管理员可后台修改数据库记录	哈希链+共识机制（需控制 51%节点）	防伪水印+多人监考
中介成本高	跨境支付手续费高达$50	点对点交易（比特币手续费<$1）	跳过旅行社直订机票
隐私泄露	中心化数据库被黑客集中攻击	非对称加密（私钥用户自主保管）	保险箱钥匙自己拿 vs 交给物业保管

核心价值：
▸ 去信任化：无需依赖第三方机构
▸ 抗审查性：数据分布式存储，无单一控制点

二、代码如何建立信任？—— 智能合约的四大信任支柱

1. 代码开源验证

   • 合约字节码公开（如 Etherscan 可查），全球开发者共同审计。
   • 类比：餐厅后厨透明化，顾客可实时监督烹饪过程。

2. 确定性执行

   • 所有节点通过 EVM（以太坊虚拟机）执行相同代码，结果完全一致。
   • 技术细节：字节码级复现，避免“我电脑显示不同”的纠纷。

3. 防篡改存储

   • 合约代码和状态写入区块链，修改需发起交易并支付手续费。
   • 安全门槛：51%攻击成本极高（参考下文攻击成本计算）。

4. 自动触发机制

   • 条件满足时自动执行（如时间戳、价格波动、投票结果）。
   • 现实映射：自动售货机投币后立即出货，无需人工干预。

Solidity 合约安全示例（防重入攻击）：

contract SecureWithdrawal {
    mapping(address => uint) public balances;
    bool private locked; // 锁标志，防止同一函数被重复调用

    function withdraw() public {
        require(!locked, "Reentrancy guard"); // (1) 检查锁状态
        locked = true; // (2) 上锁，防止并发调用
        uint amount = balances[msg.sender];
        (bool success, ) = msg.sender.call{value: amount}(""); // (3) 发起转账
        require(success, "Transfer failed"); // (4) 确认转账结果
        balances[msg.sender] = 0; // (5) 清零余额
        locked = false; // (6) 解锁
    }
}

代码逻辑：
通过locked标志位实现互斥，避免攻击者利用回调函数重复提款（如 The DAO 事件）。

三、去中心化网络是什么？—— 从微信群到区块链的进化

场景	中心化模式	去中心化模式	优势
消息传递	微信群主转述（依赖服务器）	点对点广播（如 BitTorrent）	群主失联不影响消息存档
文件存储	百度网盘单点存储	IPFS 分布式存储	服务器故障不影响文件访问
货币交易	银行系统清算（T+1 到账）	区块链点对点转账（10 分钟确认）	实时到账，无中间商扣费

核心区别：
▸ 控制权转移：用户从“租用服务”变为“拥有数据主权”。
▸ 容错性提升：部分节点故障不影响整体网络运行。

四、区块链结构怎么运作？—— 带锁的日记本链

1. 区块结构

   • 数据层：记录交易（如“A 向 B 转账 1BTC”）。
   • 元数据：前区块哈希、时间戳、难度目标。
   • 类比：每页日记包含前页摘要，修改任一页会导致后续所有页指纹失效。

2. 链式连接

   • 每个区块头包含前区块的哈希值（如Hash(Block N) = SHA256(Header)）。
   • 篡改难度：修改任一区块需重新计算后续所有区块的哈希值（算力指数级增长）。

3. 动态扩展

   • 矿工竞争打包交易，生成新区块并链接到链尾。
   • 最长链原则：网络认可工作量最大的链为有效链（避免临时分叉）。

五、非对称密码学是啥？—— 私钥即主权

概念	技术实现	现实映射
私钥	256 位随机数（如3a7f...）	保险箱钥匙（丢失则资产永久丢失）
公钥	私钥通过椭圆曲线算法生成	保险箱编号（公开，用于接收资产）
数字签名	私钥加密交易摘要	信封火漆印章（验证消息未被篡改）

安全原理：
▸ 不可逆性：通过公钥无法反推私钥（单向函数）。
▸ 唯一性：私钥与公钥一一对应，全球唯一。

六、POW 共识机制—— 算力即权力

1. 核心流程

   • 矿工竞争：通过哈希碰撞（如SHA256(Block Header + Nonce)）寻找符合难度目标的随机数。
   • 中奖规则：哈希值前 N 位为 0（如比特币前 70 位为 0）。
   • 奖励机制：获胜矿工获得区块奖励（新币+交易手续费）。

2. 难度调整

   • 目标：维持平均 10 分钟出块时间。
   • 机制：每 2016 个区块（约 2 周）根据前周期实际出块时间调整难度值。
   • 公式：新难度 = 旧难度 × (实际时间 / 目标时间)。

3. 51%攻击成本（2023 年比特币）

   参数	值
   全网算力	400 EH/s（4×10²⁰ 哈希/秒）
   攻击所需算力	>200 EH/s（控制 51%算力）
   矿机成本	$50/TerraHash（1TH=10¹² 哈希/秒）
   设备成本	200×10⁶ TH × $50 = $100 亿
   电力成本（每小时）	200 EH/s × 0.1kW/TH × $0.1/kWh = $200 万/小时

经济合理性：
攻击成本远高于收益，且攻击会导致币价暴跌，形成天然威慑。

七、现实场景秒懂—— 区块链如何改变生活？

1. 跨境汇款

   维度	传统银行	区块链
   耗时	3 天（多国银行中转）	10 分钟（点对点直达）
   费用	$50 手续费	$1 手续费
   风险	中转行扣款/汇率损失	直达无中间商

2. 网购纠纷

   • 传统流程：
     买家投诉 → 平台介入 → 举证扯皮 → 耗时数周。
   • 区块链方案：
     智能合约自动执行：

     if (买家确认收货) {
         releaseFunds(卖家);
     } else if (超时未确认) {
         refund(买家);
     }

   • 优势：零人工干预，24 小时内自动结算。

硬分叉与软分叉：区块链协议升级的双重路径

一、核心定义与本质区别

维度	硬分叉（Hard Fork）	软分叉（Soft Fork）
兼容性	不兼容旧版本，旧节点拒绝新节点区块	向后兼容，旧节点接受新节点区块
网络影响	必然分裂为两条独立链（如 ETH/ETC、BTC/BCH）	保持单链，旧节点可能成为“孤儿区块”但链不分裂
升级要求	需所有节点强制升级，否则无法参与新链	允许部分节点升级，未升级节点仍可验证旧规则区块
典型案例	以太坊 DAO 事件分叉、比特币现金分叉	比特币 SegWit 升级、BIP-66 签名验证强化

二、技术实现与案例解析

1. 硬分叉：协议的根本性变更

• 技术特征：
  修改区块或交易格式（如调整区块大小、改变共识算法），旧节点因规则不符拒绝新节点区块。
• 经典案例：
  • 以太坊 ETH/ETC 分叉：
    2016 年 The DAO 事件后，社区通过硬分叉回滚被盗资金，部分成员拒绝升级，形成两条链。
    结果：原链 ETC 保留，新链 ETH 成为主流。
  • 比特币 BTC/BCH 分叉：
    2017 年因扩容争议，支持大区块的矿工分叉出比特币现金（BCH）。
    结果：BTC 继续 1M 区块，BCH 采用 8M 区块。

2. 软分叉：向后兼容的渐进式升级

• 技术特征：
  收紧规则（如限制区块格式），旧节点虽无法验证新功能，但接受新节点区块。

• 经典案例：

  • 比特币 SegWit 升级：
    2017 年通过软分叉实现交易签名与数据分离，提升区块容量至 4M（等效）。
    结果：未升级节点仍可验证旧格式交易，网络未分裂。
  • BIP-66 签名验证：
    2015 年强化签名规则，未升级节点可能生成无效区块，但新节点拒绝其上链。
    结果：矿工逐步升级，旧规则区块被淘汰。

挖矿模拟

• hash = sha256(交易数据 + 上一个区块的哈希值 + 随机数)

// pow.js
const crypto = require("crypto");
// 完整的挖矿模拟器代码
async function mineBlock(difficulty, transactions, previousHash) {
  const prefix = "0".repeat(difficulty);
  console.log(`开始挖矿，目标: 哈希值以 ${prefix} 开头...`);

  let nonce = 0; // 随机数
  let hashCount = 0; // 哈希计算次数
  const startTime = Date.now(); // 挖矿开始时间

  while (true) {
    hashCount++;
    const blockHeader = `${transactions}${previousHash}${nonce}`;
    let hash = crypto.createHash("sha256").update(blockHeader).digest("hex");

    // 检查哈希值是否符合难度要求
    if (hash.startsWith(prefix)) {
      const elapsedTime = (Date.now() - startTime) / 1000;
      console.log(`\n成功挖到区块!`);
      console.log(`尝试次数: ${hashCount}`);
      console.log(`耗时: ${elapsedTime.toFixed(2)} 秒`);
      console.log(`Nonce: ${nonce}`);
      console.log(`哈希值: ${hash}`);
      break;
    }

    nonce++;

    // 每1000次更新一次状态
    if (hashCount % 1000 === 0) {
      process.stdout.write(`\r已尝试 ${hashCount} 次哈希计算...`);
    }
  }
}

// 难度系数-多少位哈希值以0开头
const difficulty = 6;
// 交易数据
const transactions = "Alice sends 1 BTC to Bob";
// 上一个区块的哈希值
const previousHash =
  "0000a8c0d36295638e8a4e9b45a3e3e9d3e8c7b1a3e8e8e8e8e8e8e8e8e8e8e8";

mineBlock(difficulty, transactions, previousHash).catch((err) => {
  console.error("错误:", err);
});

node pow.js

开始挖矿，目标: 哈希值以 000000 开头...
已尝试 49619000 次哈希计算...
成功挖到区块!
尝试次数: 49619265
耗时: 74.62 秒
Nonce: 49619264
哈希值: 000000718f3ee008a8d7a76e21315d33f4a773f5339595fc0d5f21d4ad69e620

交易签名与验证

const crypto = require("crypto");

/**
 * 生成 RSA 密钥对
 * @returns {Object} 包含公钥和私钥的对象
 */
function generateRSAKey() {
  const { publicKey, privateKey } = crypto.generateKeyPairSync("rsa", {
    modulusLength: 2048,
    publicKeyEncoding: {
      type: "spki",
      format: "pem",
    },
    privateKeyEncoding: {
      type: "pkcs8",
      format: "pem",
    },
  });

  return { publicKey, privateKey };
}

/**
 * 使用公钥加密数据
 * @param {string|Buffer} data 要加密的数据
 * @param {string} publicKey 公钥
 * @returns {string} - 加密后的base64字符串
 */
function encryptWithPublicKey(data, publicKey) {
  const buffer = Buffer.from(data);
  const encrypted = crypto.publicEncrypt(
    {
      key: publicKey,
      padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
      oaepHash: "sha256",
    },
    buffer
  );
  return encrypted.toString("base64");
}

/**
 * 使用私钥解密数据
 * @param {string} encryptedData 加密的base64数据
 * @param {string} privateKey 私钥
 * @returns {string} - 解密后的原始数据
 */
function decryptWithPrivateKey(encryptedData, privateKey) {
  const buffer = Buffer.from(encryptedData, "base64");
  const decrypted = crypto.privateDecrypt(
    {
      key: privateKey,
      padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
      oaepHash: "sha256",
    },
    buffer
  );
  return decrypted.toString();
}

/**
 * 使用私钥对数据进行签名
 * @param {string|Buffer} data 要签名的数据
 * @param {string} privateKey 私钥
 * @returns {string} - 签名的base64表示
 */
function signData(data, privateKey) {
  const sign = crypto.createSign("SHA256");
  sign.update(data);
  sign.end();
  return sign.sign(privateKey, "base64");
}

/**
 * 使用公钥验证签名
 * @param {string|Buffer} data 原始数据
 * @param {string} signature 签名的base64字符串
 * @param {string} publicKey 公钥
 * @returns {boolean} - 验证是否成功
 */
function verifySignature(data, signature, publicKey) {
  const verify = crypto.createVerify("SHA256");
  verify.update(data);
  verify.end();
  return verify.verify(publicKey, signature, "base64");
}

/**
 * 完整的演示函数
 */
function demo() {
  console.log("🔐 非对称加密完整演示\n");

  // 生成密钥对
  const { publicKey, privateKey } = generateRSAKey();
  console.log("✅ RSA密钥对已生成");

  const originalMessage = "这是需要保密的重要数据：Hello, RSA Encryption!";
  console.log(`\n📄 原始消息: ${originalMessage}`);

  // 演示1: 公钥加密 → 私钥解密
  console.log("\n=== 1. 公钥加密 & 私钥解密（保密性）===");

  const encrypted = encryptWithPublicKey(originalMessage, publicKey);
  console.log(`🔒 加密后 (base64): ${encrypted.substring(0, 80)}...`);

  const decrypted = decryptWithPrivateKey(encrypted, privateKey);
  console.log(`🔓 解密后: ${decrypted}`);
  console.log(`✅ 加解密成功: ${originalMessage === decrypted}`);

  // 演示2: 私钥签名 → 公钥验证（身份验证）
  console.log("\n=== 2. 私钥签名 & 公钥验证（身份验证）===");

  const signature = signData(originalMessage, privateKey);
  console.log(`📝 数字签名 (base64): ${signature.substring(0, 80)}...`);

  const isValid = verifySignature(originalMessage, signature, publicKey);
  console.log(`✅ 签名验证: ${isValid ? "有效 - 数据完整且来源可信" : "无效"}`);

  // 演示3: 篡改检测
  console.log("\n=== 3. 篡改检测演示 ===");
  const tamperedMessage = "这是被篡改的重要数据：Hello, RSA Encryption!";
  const isTamperedValid = verifySignature(
    tamperedMessage,
    signature,
    publicKey
  );
  console.log(
    `❌ 篡改后验证: ${isTamperedValid ? "有效" : "无效 - 检测到数据被篡改"}`
  );
}

demo();

function secureMessagingDemo() {
  console.log("\n\n💬 安全消息传递系统演示");
  console.log("=".repeat(50));

  // 模拟两个用户
  const aliceKeys = generateRSAKey();
  const bobKeys = generateRSAKey();

  console.log("👤 Alice 和 Bob 已生成各自的密钥对");

  // Alice 发送加密消息给 Bob
  const messageToBob = "Bob，这是我们项目的机密信息！";
  console.log(`\n📨 Alice 发送给 Bob: ${messageToBob}`);

  // 1. Alice 用 Bob 的公钥加密（保密性）
  const encryptedMessage = encryptWithPublicKey(
    messageToBob,
    bobKeys.publicKey
  );

  // 2. Alice 用自己的私钥签名（身份验证）
  const messageSignature = signData(messageToBob, aliceKeys.privateKey);

  console.log("✅ Alice: 消息已加密并签名");

  // Bob 接收消息
  console.log("\n📩 Bob 接收消息:");

  try {
    // 1. Bob 用自己的私钥解密
    const decryptedMessage = decryptWithPrivateKey(
      encryptedMessage,
      bobKeys.privateKey
    );
    console.log(`🔓 解密后的消息: ${decryptedMessage}`);

    // 2. Bob 用 Alice 的公钥验证签名
    const signatureValid = verifySignature(
      decryptedMessage,
      messageSignature,
      aliceKeys.publicKey
    );

    if (signatureValid) {
      console.log("✅ 签名验证成功: 消息确实来自 Alice，且未被篡改");
    } else {
      console.log("❌ 警告: 签名验证失败！消息可能被伪造或篡改");
    }
  } catch (error) {
    console.log("❌ 解密失败:", error.message);
  }
}

secureMessagingDemo();