1
2
3

// NewCipher 创建并返回一个使用指定密钥的 cipher.Block 接口
// 密钥长度必须是 16、24 或 32 字节
func NewCipher(key []byte) (cipher.Block, error)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

package main

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

// AES加密示例
func main() {
    // 密钥必须是 16、24 或 32 字节
    // 分别对应 AES-128、AES-192、AES-256
    key := []byte("1234567890123456") // 16字节 -> AES-128

    // 创建AES密码块
    block, err := aes.NewCipher(key)
    if err != nil {
        panic(err) // 密钥长度不对会报错
    }

    fmt.Printf("AES算法: AES-%d\n", len(key)*8)
    fmt.Printf("块大小: %d 字节\n", block.BlockSize())
    fmt.Printf("密钥: %s\n", hex.EncodeToString(key))

    // BlockSize 返回块大小（字节）
    // AES 固定为 16 字节
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

type Block interface {
    // BlockSize 返回加密块的大小（字节）
    BlockSize() int

    // Encrypt 加密 src，加密后写入 dst
    // src 和 dst 可以是同一块内存
    Encrypt(dst, src []byte)

    // Decrypt 解密 src，解密后写入 dst
    Decrypt(dst, src []byte)
}

1
2
3
4
5

// BlockMode 是分组密码模式的接口
type BlockMode interface {
    BlockSize() int           // 返回块大小
    CryptBlocks(dst, src []byte) // 加密/解密多个块
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/hex"
    "fmt"
    "io"
)

// CBC模式加密示例
func main() {
    // 16字节密钥 -> AES-128
    key := []byte("1234567890123456")

    // 创建AES密码块
    block, err := aes.NewCipher(key)
    if err != nil {
        panic(err)
    }

    // 原文（必须是块大小的倍数，这里需要padding）
    plaintext := []byte("Hello, CBC Mode! 这是一条加密测试消息")

    // 步骤1：填充（PKCS7 padding）
    blockSize := block.BlockSize()
    padding := blockSize - len(plaintext)%blockSize
    paddedText := make([]byte, len(plaintext)+padding)
    copy(paddedText, plaintext)
    for i := len(plaintext); i < len(paddedText); i++ {
        paddedText[i] = byte(padding) // 填充值为padding长度
    }

    fmt.Printf("原文长度: %d 字节\n", len(plaintext))
    fmt.Printf("填充后长度: %d 字节（填充了 %d 字节）\n", len(paddedText), padding)
    fmt.Printf("填充内容: %v\n", paddedText[len(plaintext):])

    // 步骤2：生成随机IV
    iv := make([]byte, blockSize)
    if _, err := io.ReadFull(rand.Reader, iv); err != nil {
        panic(err)
    }

    fmt.Printf("IV: %s\n", hex.EncodeToString(iv))

    // 步骤3：CBC模式加密
    ciphertext := make([]byte, len(paddedText))
    mode := cipher.NewCBCEncrypter(block, iv)
    mode.CryptBlocks(ciphertext, paddedText)

    fmt.Printf("密文: %s\n", hex.EncodeToString(ciphertext))

    // ============ 解密过程 ============

    // 步骤4：创建CBC解密器
    decryptMode := cipher.NewCBCDecrypter(block, iv)

    // 步骤5：解密（注意：解密会直接修改数据，这里用副本）
    decrypted := make([]byte, len(ciphertext))
    decryptMode.CryptBlocks(decrypted, ciphertext)

    // 步骤6：去除padding
    unpadding := int(decrypted[len(decrypted)-1])
    originalText := decrypted[:len(decrypted)-unpadding]

    fmt.Printf("解密后原文: %s\n", string(originalText))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/hex"
    "fmt"
    "io"
)

// CTR模式示例
func main() {
    key := []byte("1234567890123456") // 16字节 AES-128

    block, err := aes.NewCipher(key)
    if err != nil {
        panic(err)
    }

    // CTR最大的优点：不需要padding！
    plaintext := []byte("Hello, CTR Mode! Stream cipher, no padding needed!")

    // 创建Noncer接口（CTR使用nonce而不是IV）
    nonce := make([]byte, block.BlockSize())
    if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
        panic(err)
    }

    fmt.Printf("原文长度: %d 字节（无需填充！）\n", len(plaintext))
    fmt.Printf("Nonce: %s\n", hex.EncodeToString(nonce))

    // 创建CTR模式（加密解密用同一个函数）
    stream := cipher.NewCTR(block, nonce)

    // 加密
    ciphertext := make([]byte, len(plaintext))
    stream.XORKeyStream(ciphertext, plaintext)

    fmt.Printf("密文: %s\n", hex.EncodeToString(ciphertext))

    // ============ 解密 ============
    // CTR解密和加密完全一样！都是XOR密钥流
    stream2 := cipher.NewCTR(block, nonce)
    decrypted := make([]byte, len(ciphertext))
    stream2.XORKeyStream(decrypted, ciphertext)

    fmt.Printf("解密后原文: %s\n", string(decrypted))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/hex"
    "fmt"
    "io"
)

// GCM模式示例 - 推荐使用的AEAD模式
func main() {
    key := []byte("1234567890123456") // 16字节 AES-128

    block, err := aes.NewCipher(key)
    if err != nil {
        panic(err)
    }

    // 创建GCM模式
    // nonce通常用12字节（96位），这是GCM推荐的长度
    nonce := make([]byte, 12)
    if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
        panic(err)
    }

    plaintext := []byte("Hello, GCM Mode! 这是带认证的加密消息")

    fmt.Printf("原文: %s\n", string(plaintext))
    fmt.Printf("Nonce: %s\n", hex.EncodeToString(nonce))

    // ===== 加密并认证 =====
    // Seal函数返回 密文+认证标签 的拼接
    ciphertext := make([]byte, 0, len(plaintext)+block.BlockSize())
    sealed := cipher.NewGCM(block).Seal(ciphertext, nonce, plaintext, nil)

    // sealed = nonce || ciphertext || tag
    fmt.Printf("加密后总长度: %d 字节\n", len(sealed))
    fmt.Printf("密文+标签: %s\n", hex.EncodeToString(sealed[len(nonce):]))

    // ===== 解密并验证 =====
    // Open函数会验证tag，如果数据被篡改会返回错误
    decrypted, err := cipher.NewGCM(block).Open(nil, nonce, sealed, nil)
    if err != nil {
        fmt.Printf("认证失败！数据可能被篡改: %v\n", err)
        return
    }

    fmt.Printf("解密后原文: %s\n", string(decrypted))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "fmt"
)

// 模拟数据被篡改的情况
func main() {
    key := []byte("1234567890123456")
    block, _ := aes.NewCipher(key)
    gcm, _ := cipher.NewGCM(block)

    nonce := []byte("123456789012") // 12字节
    plaintext := []byte("Secret message")

    // 加密
    sealed := gcm.Seal(nil, nonce, plaintext, nil)

    // 模拟篡改：修改密文的某个字节
    sealed[len(sealed)-5] ^= 0xFF // 篡改！

    // 解密时会失败
    _, err := gcm.Open(nil, nonce, sealed, nil)
    if err != nil {
        fmt.Printf("✅ 认证成功！GCM检测到数据被篡改: %v\n", err)
    } else {
        fmt.Println("❌ 认证失败！未能检测到篡改")
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

type AEAD interface {
    // NonceSize 返回nonce的大小（字节）
    NonceSize() int

    // Overhead 返回密文比明文多出的字节数（通常是标签大小）
    Overhead() int

    // Seal 加密并认证明文
    // ciphertext = nonce || actual_ciphertext || tag
    Seal(dst, nonce, plaintext, additionalData []byte) []byte

    // Open 解密并验证密文
    // 如果验证失败，返回错误
    Open(dst, nonce, ciphertext, additionalData []byte) ([]byte, error)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/hex"
    "fmt"
    "io"
)

// AEAD接口完整示例
func main() {
    key := make([]byte, 32) // 32字节 -> AES-256（最安全）
    io.ReadFull(rand.Reader, key)

    block, err := aes.NewCipher(key)
    if err != nil {
        panic(err)
    }

    gcm, err := cipher.NewGCM(block)
    if err != nil {
        panic(err)
    }

    nonce := make([]byte, gcm.NonceSize())
    io.ReadFull(rand.Reader, nonce)

    plaintext := []byte("Sensitive data with AEAD protection")
    aad := []byte("associated data to authenticate") // 额外认证数据

    fmt.Printf("AEAD类型: %T\n", gcm)
    fmt.Printf("Nonce大小: %d 字节\n", gcm.NonceSize())
    fmt.Printf("Overhead: %d 字节（认证标签大小）\n", gcm.Overhead())

    // 加密 + 认证
    ciphertext := gcm.Seal(nil, nonce, plaintext, aad)

    // 解密 + 验证
    decrypted, err := gcm.Open(nil, nonce, ciphertext, aad)
    if err != nil {
        panic(err)
    }

    fmt.Printf("原文: %s\n", plaintext)
    fmt.Printf("密文: %s\n", hex.EncodeToString(ciphertext[len(nonce):]))
    fmt.Printf("解密: %s\n", string(decrypted))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

package main

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

// MD5示例 - 仅用于兼容性，不推荐新代码
func main() {
    // MD5产生128位（16字节）的哈希值
    data := []byte("Hello, MD5!")

    // 方式1：直接计算
    hash1 := md5.Sum(data) // 返回 [16]byte
    fmt.Printf("MD5直接计算: %x\n", hash1)

    // 方式2：使用Writer模式（流式计算）
    h := md5.New()
    h.Write(data)
    hash2 := h.Sum(nil)
    fmt.Printf("MD5 Writer模式: %s\n", hex.EncodeToString(hash2))

    // 验证两种方式结果一致
    fmt.Printf("结果一致: %v\n", hash1 == [16]byte(hash2))

    // MD5的特点
    fmt.Printf("\n=== MD5特性 ===\n")
    fmt.Printf("哈希长度: %d 字节 = %d 位\n", md5.Size, md5.Size*8)
    fmt.Printf("块大小: %d 字节\n", md5.BlockSize)

    // 相同输入产生相同输出
    fmt.Printf("\n'Hello' -> %x\n", md5.Sum([]byte("Hello")))
    fmt.Printf("'Hello' -> %x\n", md5.Sum([]byte("Hello")))
    fmt.Printf("'hello' -> %x（小写h不同）\n", md5.Sum([]byte("hello")))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package main

import (
    "crypto/md5"
    "fmt"
)

// 用于检查文件完整性（旧格式校验）
func main() {
    // 场景：验证下载文件的checksum（老项目兼容）
    fmt.Println("=== MD5兼容性场景 ===")
    fmt.Println("1. 旧系统的密码存储（不要再用了！）")
    fmt.Println("2. 文件完整性校验（旧ISO镜像）")
    fmt.Println("3. 数字签名的兼容层")

    // 典型用法：校验下载文件
    expected := "d41d8cd98f00b204e9800998ecf8427e" // 空文件的MD5
    fmt.Printf("预期MD5: %s\n", expected)

    hash := md5.Sum(nil)
    fmt.Printf("空文件MD5: %x\n", hash)
    fmt.Printf("匹配: %v\n", fmt.Sprintf("%x", hash) == expected)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

package main

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

// SHA-1示例 - 已废弃，仅用于兼容性
func main() {
    data := []byte("Hello, SHA-1!")

    // 方式1：直接计算
    hash1 := sha1.Sum(data) // 返回 [20]byte
    fmt.Printf("SHA-1直接计算: %x\n", hash1)

    // 方式2：Writer模式
    h := sha1.New()
    h.Write(data)
    hash2 := h.Sum(nil)
    fmt.Printf("SHA-1 Writer模式: %s\n", hex.EncodeToString(hash2))

    fmt.Printf("\n=== SHA-1特性 ===\n")
    fmt.Printf("哈希长度: %d 字节 = %d 位\n", sha1.Size, sha1.Size*8)
    fmt.Printf("块大小: %d 字节\n", sha1.BlockSize)

    // SHA-1 vs MD5
    fmt.Printf("\n=== SHA-1 vs MD5 ===\n")
    fmt.Printf("MD5输出:  %d 位\n", 128)
    fmt.Printf("SHA-1输出: %d 位\n", 160)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

package main

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

// SHA-256示例
func main() {
    data := []byte("Hello, SHA-256!")

    // SHA-256直接计算
    hash := sha256.Sum256(data) // 返回 [32]byte
    fmt.Printf("SHA-256: %x\n", hash)
    fmt.Printf("长度: %d 字节 = %d 位\n", sha256.Size, sha256.Size*8)

    // SHA-224使用不同的初始值和输出截断
    hash224 := sha256.Sum224(data)
    fmt.Printf("SHA-224: %x\n", hash224)

    // Writer模式
    h := sha256.New()
    h.Write(data)
    fmt.Printf("Writer: %s\n", hex.EncodeToString(h.Sum(nil)))

    // 雪崩效应：输入改变一位，输出完全不同
    fmt.Printf("\n=== 雪崩效应演示 ===\n")
    a := sha256.Sum256([]byte("hello"))
    b := sha256.Sum256([]byte("hellp")) // 只改了一个字符
    fmt.Printf("'hello' -> %x\n", a)
    fmt.Printf("'hellp' -> %x\n", b)

    // 统计不同位数
    diff := 0
    for i := range a {
        x := a[i] ^ b[i]
        for x > 0 {
            diff += int(x & 1)
            x >>= 1
        }
    }
    fmt.Printf("不同位数: %d/%d (%.1f%%)\n", diff, 256, float64(diff)/256*100)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

package main

import (
    "crypto/sha256"
    "fmt"
)

// 典型应用：密码存储、文件校验、区块链
func main() {
    fmt.Println("=== SHA-256典型应用 ===")

    // 1. 密码存储（加盐）
    fmt.Println("\n1. 密码存储（实际用bcrypt，这里演示原理）")
    salt := []byte("random_salt_123")
    password := []byte("user_password")
    saltedHash := sha256.Sum256(append(salt, password...))
    fmt.Printf("加盐哈希: %x\n", saltedHash)

    // 2. 文件完整性校验
    fmt.Println("\n2. 文件完整性校验")
    fileContent := []byte("Important document content")
    fileHash := sha256.Sum256(fileContent)
    fmt.Printf("文件SHA-256: %x\n", fileHash)

    // 3. Git使用的就是SHA-1（现在也在迁移到SHA-256）
    fmt.Println("\n3. Git版本控制（Git 2.29+支持SHA-256）")
    commit := []byte("commit content")
    commitHash := sha256.Sum256(commit)
    fmt.Printf("Commit哈希: %x\n", commitHash)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

package main

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

// SHA-512系列示例
func main() {
    data := []byte("Hello, SHA-512!")

    // SHA-512
    hash512 := sha512.Sum512(data)
    fmt.Printf("SHA-512: %x\n", hash512)
    fmt.Printf("长度: %d 字节\n", sha512.Size)

    // SHA-384（截断版本）
    hash384 := sha512.Sum384(data)
    fmt.Printf("SHA-384: %x\n", hash384)
    fmt.Printf("长度: %d 字节\n", sha512.Size384)

    // SHA-512/224 和 SHA-512/256
    hash512_224 := sha512.Sum512_224(data)
    hash512_256 := sha512.Sum512_256(data)
    fmt.Printf("SHA-512/224: %x (%d 字节)\n", hash512_224, sha512.Size224)
    fmt.Printf("SHA-512/256: %x (%d 字节)\n", hash512_256, sha512.Size256)

    // Writer模式
    h := sha512.New()
    h.Write(data)
    fmt.Printf("\nWriter模式: %x\n", h.Sum(nil))

    // 性能对比
    fmt.Printf("\n=== SHA-512 vs SHA-256 ===\n")
    largeData := make([]byte, 1024*1024) // 1MB数据

    // SHA-256
    h256 := sha256.New()
    h256.Write(largeData)
    fmt.Printf("SHA-256: %x (1MB数据)\n", h256.Sum(nil)[:16])

    // SHA-512
    h512 := sha512.New()
    h512.Write(largeData)
    fmt.Printf("SHA-512: %x (1MB数据)\n", h512.Sum(nil)[:16])
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package main

import (
    "crypto/sha512"
    "fmt"
)

// SHA-512应用场景
func main() {
    fmt.Println("=== SHA-512应用场景 ===")

    // DNSSEC（DNS安全扩展）
    fmt.Println("1. DNSSEC - DNS记录签名")
    dnsRecord := []byte("example.com IN A 93.184.216.34")
    dnsHash := sha512.Sum512(dnsRecord)
    fmt.Printf("DNS记录哈希: %x\n", dnsHash[:16])

    // TLS证书
    fmt.Println("\n2. TLS证书指纹（现代浏览器）")
    cert := []byte("Certificate data for TLS handshake")
    certHash := sha512.Sum384([]byte(cert))
    fmt.Printf("证书指纹: %x\n", certHash)

    // 比特币（比特币用SHA-256，但其他加密货币可能用SHA-512）
    fmt.Println("\n3. 某些区块链的Merkle树")
    tx1 := []byte("tx1_data")
    tx2 := []byte("tx2_data")
    h1 := sha512.Sum512(tx1)
    h2 := sha512.Sum512(tx2)
    combined := append(h1[:], h2[:]...)
    merkle := sha512.Sum512(combined)
    fmt.Printf("Merkle根: %x\n", merkle[:16])
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

package main

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

// SHA-3示例
func main() {
    data := []byte("Hello, SHA-3!")

    // 固定长度哈希
    fmt.Println("=== 固定长度SHA-3 ===")

    h224 := sha3.New224()
    h224.Write(data)
    fmt.Printf("SHA3-224: %x (%d 字节)\n", h224.Sum(nil), 28)

    h256 := sha3.New256()
    h256.Write(data)
    fmt.Printf("SHA3-256: %x (%d 字节)\n", h256.Sum(nil), 32)

    h384 := sha3.New384()
    h384.Write(data)
    fmt.Printf("SHA3-384: %x (%d 字节)\n", h384.Sum(nil), 48)

    h512 := sha3.New512()
    h512.Write(data)
    fmt.Printf("SHA3-512: %x (%d 字节)\n", h512.Sum(nil), 64)

    // 可变长度输出（SHAKE）
    fmt.Println("\n=== 可变长度SHAKE ===")

    // SHAKE128 - 可生成任意长度的输出
    shake128 := sha3.NewShake128()
    shake128.Write(data)
    output := make([]byte, 32) // 任意长度
    shake128.Read(output)
    fmt.Printf("SHAKE128(32字节): %s\n", hex.EncodeToString(output))

    shake256 := sha3.NewShake256()
    shake256.Write(data)
    output64 := make([]byte, 64)
    shake256.Read(output64)
    fmt.Printf("SHAKE256(64字节): %s\n", hex.EncodeToString(output64))

    // SHAKE应用：可扩展输出函数（XOF）
    fmt.Println("\n=== SHAKE应用：XOF ===")
    // 可以先用短哈希，如果不够长再扩展
    shortOutput := make([]byte, 16)
    longOutput := make([]byte, 64)
    shake256.Read(shortOutput)
    shake256.Read(longOutput) // 继续从上次的位置读取
    fmt.Printf("扩展输出: %s\n", hex.EncodeToString(longOutput))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

package main

import (
    "hash/crc32"
    "fmt"
)

// CRC32示例
func main() {
    data := []byte("Hello, CRC32!")

    // 方式1：使用IEEE标准（默认）
    crc := crc32.Checksum(data, crc32.MakeTable(crc32.IEEE))
    fmt.Printf("CRC-32 (IEEE): %08x\n", crc)

    // 方式2：使用Castagnoli多项式（推荐，更高效）
    crcC := crc32.Checksum(data, crc32.MakeTable(crc32.Castagnoli))
    fmt.Printf("CRC-32 (Castagnoli): %08x\n", crcC)

    // 预计算表格加速
    fmt.Printf("\n=== 预计算表格 ===")
    ieeeTable := crc32.MakeTable(crc32.IEEE)
    castagnoliTable := crc32.MakeTable(crc32.Castagnoli)

    // Writer模式
    w := crc32.New(ieeeTable)
    w.Write([]byte("Hello"))
    w.Write([]byte(", "))
    w.Write([]byte("CRC32!"))
    fmt.Printf("\nWriter模式CRC: %08x\n", w.Sum32())

    // 大文件校验演示
    fmt.Printf("\n=== 大文件模拟 ===")
    largeData := make([]byte, 1024*1024) // 1MB
    for i := range largeData {
        largeData[i] = byte(i % 256)
    }
    checksum := crc32.Checksum(largeData, castagnoliTable)
    fmt.Printf("1MB数据CRC: %08x\n", checksum)

    // 即使改变一个位，CRC也会变化
    largeData[0] ^= 0x01 // 只改一个位
    checksum2 := crc32.Checksum(largeData, castagnoliTable)
    fmt.Printf("改变1位后CRC: %08x\n", checksum2)
    fmt.Printf("CRC不同: %v\n", checksum != checksum2)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

package main

import (
    "hash/crc32"
    "fmt"
    "runtime"
)

// CRC32C可能有硬件支持
func main() {
    fmt.Println("=== CRC32C硬件支持检测 ===")
    fmt.Printf("CPU核心数: %d\n", runtime.NumCPU())

    // 在支持的CPU上（Intel Haswell+, AMD Zen+），CRC32C有硬件指令
    // Go会自动使用硬件加速

    table := crc32.MakeTable(crc32.Castagnoli)
    data := []byte("Hardware accelerated CRC32C")

    // 这个函数在支持硬件加速的CPU上会非常快
    checksum := crc32.Checksum(data, table)
    fmt.Printf("CRC32C: %08x\n", checksum)
    fmt.Println("（如果有硬件支持，这会非常快！）")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

package main

import (
    "hash/fnv"
    "fmt"
)

// FNV哈希示例
func main() {
    fmt.Println("=== FNV哈希家族 ===")

    // FNV-1a（推荐使用）
    data := []byte("Hello, FNV!")

    // FNV-1a 32位
    h32 := fnv.New32a()
    h32.Write(data)
    fmt.Printf("FNV-1a 32位: %08x\n", h32.Sum32())

    // FNV-1 32位
    h32_1 := fnv.New32()
    h32_1.Write(data)
    fmt.Printf("FNV-1 32位: %08x\n", h32_1.Sum32())

    // FNV-1a 64位
    h64 := fnv.New64a()
    h64.Write(data)
    fmt.Printf("FNV-1a 64位: %x\n", h64.Sum64())

    // FNV-1a 128位（返回两个64位）
    h128 := fnv.New128a()
    h128.Write(data)
    sum128 := h128.Sum(nil)
    fmt.Printf("FNV-1a 128位: %x\n", sum128)

    // Writer模式
    fmt.Println("\n=== Writer模式 ===")
    w := fnv.New32a()
    w.Write([]byte("Hello"))
    w.Write([]byte(", "))
    w.Write([]byte("FNV!"))
    fmt.Printf("分步写入结果: %08x\n", w.Sum32())

    // 一次性写入
    single := fnv.New32a()
    single.Write([]byte("Hello, FNV!"))
    fmt.Printf("一次性写入: %08x\n", single.Sum32())
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

package main

import (
    "hash/fnv"
    "fmt"
)

// FNV应用场景
func main() {
    fmt.Println("=== FNV应用场景 ===")

    // 1. 哈希表
    fmt.Println("\n1. 哈希表（Go的map内部使用自己的哈希算法，非FNV）")
    m := make(map[uint32]string)
    h := fnv.New32a()
    h.Write([]byte("key"))
    keyHash := h.Sum32()
    m[keyHash] = "value"
    fmt.Printf("键'key'的FNV哈希: %08x\n", keyHash)
    fmt.Printf("map中存储在索引: %d\n", keyHash%16)

    // 2. Bloom Filter（布隆过滤器）
    fmt.Println("\n2. Bloom Filter")
    // 简单的Bloom Filter会用多个哈希函数
    item := []byte("example")
    hashes := []uint32{
        fnvHash32(item, 0),
        fnvHash32(item, 1),
        fnvHash32(item, 2),
    }
    fmt.Printf("Bloom Filter的3个哈希位置: %v\n", hashes)

    // 3. 一致性哈希
    fmt.Println("\n3. 一致性哈希")
    servers := []string{"server1", "server2", "server3"}
    key := []byte("user123")
    server := consistentHash(servers, key)
    fmt.Printf("键'user123'应该路由到: %s\n", server)
}

// 简单的FNV变体（带种子）
func fnvHash32(data []byte, seed int) uint32 {
    h := fnv.New32a()
    h.Write(data)
    h.Write([]byte(fmt.Sprintf("%d", seed)))
    return h.Sum32()
}

func consistentHash(servers []string, key []byte) string {
    h := fnv.New32a()
    h.Write(key)
    hash := h.Sum32()
    idx := int(hash) % len(servers)
    return servers[idx]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

package main

import (
    "hash/maphash"
    "fmt"
    "runtime"
)

// maphash示例
func main() {
    fmt.Println("=== hash/maphash 抗哈希泛洪 ===")

    // 基础用法
    seed := maphash.MakeSeed() // 创建随机种子
    fmt.Printf("Seed: %v\n", seed)

    // 方式1：使用固定的seed
    h := maphash.New(seed)
    h.WriteString("Hello")
    h.WriteString(" maphash")
    fmt.Printf("哈希值: %x\n", h.Sum64())

    // 方式2：Bytes函数（简便写法）
    hash1 := maphash.Bytes(seed, []byte("test"))
    hash2 := maphash.Bytes(seed, []byte("test"))
    fmt.Printf("Bytes函数: %x\n", hash1)
    fmt.Printf("相同输入相同哈希: %v\n", hash1 == hash2)

    // 方式3：String函数（针对字符串优化）
    hashStr := maphash.String(seed, "test string")
    fmt.Printf("String函数: %x\n", hashStr)

    // 系统级seed
    fmt.Println("\n=== 系统级保护 ===")
    systemSeed := maphash.MakeSeed()
    fmt.Printf("系统Seed: %v\n", systemSeed)

    // 每个goroutine有不同的seed（自动）
    fmt.Printf("当前Goroutine数量: %d\n", runtime.NumGoroutine())

    // 模拟哈希表
    fmt.Println("\n=== 模拟哈希表 ===")
    simulateHashTable()
}

func simulateHashTable() {
    // 创建一个"哈希表"
    type entry struct {
        key   string
        value string
    }

    table := make([]entry, 16)
    seed := maphash.MakeSeed()

    // 添加几个元素
    items := []struct {
        k, v string
    }{
        {"name", "Alice"},
        {"age", "30"},
        {"city", "Beijing"},
    }

    for _, item := range items {
        h := maphash.New(seed)
        h.WriteString(item.k)
        idx := int(h.Sum64()) % len(table)

        // 找空槽（简化版，实际要处理冲突）
        for table[idx].key != "" {
            idx = (idx + 1) % len(table)
        }
        table[idx] = entry{key: item.k, value: item.v}
        fmt.Printf("'%s' 哈希到索引: %d\n", item.k, idx)
    }

    // 查询
    key := "city"
    h := maphash.New(seed)
    h.WriteString(key)
    idx := int(h.Sum64()) % len(table)
    fmt.Printf("\n查询'%s'，检查索引 %d\n", key, idx)
    fmt.Printf("找到: %s = %s\n", table[idx].key, table[idx].value)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

package main

import (
    "fmt"
    "hash/fnv"
    "hash/maphash"
)

// 对比maphash和FNV
func main() {
    fmt.Println("=== maphash vs FNV ===")

    data := []byte("test key")

    // FNV（没有内置保护）
    f := fnv.New32a()
    f.Write(data)
    fmt.Printf("FNV-1a:   %08x (可能被预测)\n", f.Sum32())

    // maphash（有保护）
    seed := maphash.MakeSeed()
    h := maphash.New(seed)
    h.Write(data)
    fmt.Printf("maphash:  %016x (随机种子)\n", h.Sum64())

    fmt.Println("\n=== 安全性对比 ===")
    fmt.Println("FNV:   攻击者可预测哈希值，可构造哈希泛洪")
    fmt.Println("maphash: 每次运行种子不同，难以预测")
    fmt.Println("\n结论：用于哈希表时，优先使用maphash！")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// AES-256 + GCM（推荐配置）
key := make([]byte, 32) // 32字节 = AES-256
block, _ := aes.NewCipher(key)
gcm, _ := cipher.NewGCM(block)
nonce := make([]byte, 12)
rand.Read(nonce)
ciphertext := gcm.Seal(nil, nonce, plaintext, nil)

// SHA-256哈希
hash := sha256.Sum256(data)

// CRC32校验
table := crc32.MakeTable(crc32.Castagnoli)
checksum := crc32.Checksum(data, table)

// 安全的哈希表哈希
seed := maphash.MakeSeed()
h := maphash.New(seed)
h.WriteString("key")
hash := h.Sum64()