区块链基础与密码学

package main

import (
    "crypto/sha256"
    "encoding/hex"
    "fmt"
)

func main() {
    data := "hello"

    // SHA-256
    hash := sha256.Sum256([]byte(data))
    hashHex := hex.EncodeToString(hash[:])

    fmt.Printf("SHA-256(%s) = %s\n", data, hashHex)

    // 验证雪崩效应
    data2 := "hello!"
    hash2 := sha256.Sum256([]byte(data2))
    hashHex2 := hex.EncodeToString(hash2[:])

    fmt.Printf("SHA-256(%s) = %s\n", data2, hashHex2)
}

package main

import (
    "crypto/ecdsa"
    "crypto/elliptic"
    "crypto/rand"
    "fmt"
)

func main() {
    // 生成私钥
    privateKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
    if err != nil {
        panic(err)
    }

    // 导出公钥
    publicKey := privateKey.PublicKey

    fmt.Printf("私钥: %x\n", privateKey.D.Bytes())
    fmt.Printf("公钥X: %x\n", publicKey.X.Bytes())
    fmt.Printf("公钥Y: %x\n", publicKey.Y.Bytes())
}

package main

import (
    "crypto/ecdsa"
    "crypto/elliptic"
    "crypto/rand"
    "crypto/sha256"
    "fmt"
    "math/big"
)

func main() {
    // 1. 生成密钥对
    privateKey, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
    publicKey := &privateKey.PublicKey

    // 2. 待签名的消息
    message := []byte("Transfer 10 BTC to Alice")
    hash := sha256.Sum256(message)

    // 3. 签名
    r, s, err := ecdsa.Sign(rand.Reader, privateKey, hash[:])
    if err != nil {
        panic(err)
    }
    fmt.Printf("签名 (r, s):\n")
    fmt.Printf("r = %x\n", r)
    fmt.Printf("s = %x\n", s)

    // 4. 验证签名
    valid := ecdsa.Verify(publicKey, hash[:], r, s)
    fmt.Printf("签名验证: %v\n", valid)

    // 5. 篡改消息后验证
    tamperedMessage := []byte("Transfer 100 BTC to Alice")
    tamperedHash := sha256.Sum256(tamperedMessage)
    validAfterTamper := ecdsa.Verify(publicKey, tamperedHash[:], r, s)
    fmt.Printf("篡改后验证: %v\n", validAfterTamper)
}

package main

import (
    "crypto/sha256"
    "encoding/hex"
    "fmt"
)

type MerkleTree struct {
    RootNode *MerkleNode
}

type MerkleNode struct {
    Left  *MerkleNode
    Right *MerkleNode
    Data  []byte
}

func NewMerkleNode(left, right *MerkleNode, data []byte) *MerkleNode {
    node := &MerkleNode{}

    if left == nil && right == nil {
        // 叶子节点:直接哈希数据
        hash := sha256.Sum256(data)
        node.Data = hash[:]
    } else {
        // 非叶子节点:哈希子节点的拼接
        prevHashes := append(left.Data, right.Data...)
        hash := sha256.Sum256(prevHashes)
        node.Data = hash[:]
    }

    node.Left = left
    node.Right = right
    return node
}

func NewMerkleTree(data [][]byte) *MerkleTree {
    var nodes []*MerkleNode

    // 创建叶子节点
    for _, datum := range data {
        node := NewMerkleNode(nil, nil, datum)
        nodes = append(nodes, node)
    }

    // 如果节点数量为奇数,复制最后一个节点
    if len(nodes)%2 != 0 {
        nodes = append(nodes, nodes[len(nodes)-1])
    }

    // 构建树
    for len(nodes) > 1 {
        var level []*MerkleNode

        for i := 0; i < len(nodes); i += 2 {
            node := NewMerkleNode(nodes[i], nodes[i+1], nil)
            level = append(level, node)
        }

        nodes = level

        if len(nodes)%2 != 0 && len(nodes) > 1 {
            nodes = append(nodes, nodes[len(nodes)-1])
        }
    }

    return &MerkleTree{nodes[0]}
}

func main() {
    data := [][]byte{
        []byte("Transaction A"),
        []byte("Transaction B"),
        []byte("Transaction C"),
        []byte("Transaction D"),
    }

    tree := NewMerkleTree(data)

    fmt.Printf("Merkle Root: %s\n", hex.EncodeToString(tree.RootNode.Data))
}