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

package main

import (
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha256"
	"fmt"
	"log"
)

// 生成 RSA 密钥对
func generateRSAKey(bits int) *rsa.PrivateKey {
	// rsa.GenerateKey 使用随机源生成指定位数的 RSA 私钥
	// 它内部会自动生成两个大质数 p 和 q，使得 n = p*q
	privateKey, err := rsa.GenerateKey(rand.Reader, bits)
	if err != nil {
		log.Fatalf("密钥生成失败: %v", err)
	}
	return privateKey
}

func main() {
	// Step 1: 生成 2048 位的 RSA 密钥对（推荐最小安全长度）
	privateKey := generateRSAKey(2048)
	publicKey := &privateKey.PublicKey // 公钥从私钥派生

	// Step 2: 准备要加密的消息
	originalMessage := []byte("你好，RSA！这就是传说中的公钥加密。")
	fmt.Printf("原文: %s\n", originalMessage)

	// Step 3: 使用 OAEP 加密（更安全，推荐使用）
	// OAEP (Optimal Asymmetric Encryption Padding) 是一种填充方案
	// 它在加密前对明文进行随机化和填充，防止选择密文攻击
	label := []byte("")                                     // 可选的关联数据
	hash := sha256.New()                                    // 哈希函数
	encryptedBytes, err := rsa.EncryptOAEP(hash, rand.Reader, publicKey, originalMessage, label)
	if err != nil {
		log.Fatalf("加密失败: %v", err)
	}
	fmt.Printf("加密后（十六进制）: %x...（省略中间部分）\n", encryptedBytes[:32])

	// Step 4: 使用 OAEP 解密
	decryptedBytes, err := rsa.DecryptOAEP(hash, rand.Reader, privateKey, encryptedBytes, label)
	if err != nil {
		log.Fatalf("解密失败: %v", err)
	}
	fmt.Printf("解密后: %s\n", decryptedBytes)

	// Step 5: 验证解密结果与原文一致
	if string(decryptedBytes) == string(originalMessage) {
		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
49
50
51
52
53
54

package main

import (
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha256"
	"fmt"
	"log"
)

// 对称密钥（通常是 AES 密钥，比如 32 字节）
func generateSymmetricKey() []byte {
	key := make([]byte, 32) // 256 位的 AES 密钥
	_, err := rand.Read(key)
	if err != nil {
		log.Fatalf("对称密钥生成失败: %v", err)
	}
	return key
}

func main() {
	// 生成 RSA 密钥对
	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
	if err != nil {
		log.Fatalf("RSA 密钥生成失败: %v", err)
	}
	publicKey := &privateKey.PublicKey

	// 场景：Alice 想安全地发送一个 AES 对称密钥给 Bob
	// （在真实场景中，对称加密用于加密大文件，RSA 用于加密这个对称密钥）

	symmetricKey := generateSymmetricKey() // 模拟生成的 AES 密钥
	fmt.Printf("AES 对称密钥: %x\n", symmetricKey)

	// Bob 用自己的 RSA 公钥加密 AES 密钥后发给 Alice
	hash := sha256.New()
	encryptedKey, err := rsa.EncryptOAEP(hash, rand.Reader, publicKey, symmetricKey, nil)
	if err != nil {
		log.Fatalf("加密对称密钥失败: %v", err)
	}
	fmt.Printf("RSA 加密后的对称密钥: %x...（省略中间部分）\n", encryptedKey[:32])

	// Alice 收到加密的对称密钥，用 Bob 的 RSA 私钥解密
	decryptedKey, err := rsa.DecryptOAEP(hash, rand.Reader, privateKey, encryptedKey, nil)
	if err != nil {
		log.Fatalf("解密对称密钥失败: %v", err)
	}
	fmt.Printf("解密后的对称密钥: %x\n", decryptedKey)

	// 验证：解密得到的密钥与原始密钥一致
	if string(decryptedKey) == string(symmetricKey) {
		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
49
50
51
52
53
54
55
56
57
58
59

package main

import (
	"crypto"
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha256"
	"fmt"
	"log"
)

func main() {
	// Step 1: 生成 RSA 密钥对
	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
	if err != nil {
		log.Fatalf("RSA 密钥生成失败: %v", err)
	}
	publicKey := &privateKey.PublicKey

	// Step 2: 准备要签名的消息
	message := []byte("这是一份重要的合同，请确认签署。")
	fmt.Printf("待签名消息: %s\n", message)

	// Step 3: 使用 PSS 签名
	// rsa.SignPSS 参数：
	// - rand: 随机源（用于 PSS 的随机化）
	// - privateKey: RSA 私钥
	// - hash: 哈希算法（SHA-256 推荐）
	// - messageHash: 消息的哈希值（先哈希消息，再签名哈希值）
	// - saltLength: 盐的长度（rsa.PSSSaltLengthAuto 自动选择）

	messageHash := sha256.Sum256(message) // 先对消息进行哈希
	signature, err := rsa.SignPSS(rand.Reader, privateKey, &rsa.SHA256_PSSParms{}, messageHash[:], nil)
	if err != nil {
		log.Fatalf("PSS 签名失败: %v", err)
	}
	fmt.Printf("PSS 签名（十六进制）: %x...（省略中间部分）\n", signature[:32])

	// Step 4: 验证签名
	// rsa.VerifyPSS 参数：
	// - publicKey: RSA 公钥
	// - hash: 哈希算法
	// - messageHash: 消息的哈希值
	// - sig: 要验证的签名
	// - saltLength: 盐长度（必须与签名时一致）
	err = rsa.VerifyPSS(publicKey, crypto.SHA256, messageHash[:], signature, nil)
	if err != nil {
		log.Fatalf("❌ 签名验证失败: %v", err)
	}
	fmt.Println("✅ PSS 签名验证成功！")

	// Step 5: 篡改消息后验证（模拟攻击）
	tamperedMessage := []byte("这是一份重要的合同，请转账 100 万到 xxx 账户。")
	tamperedHash := sha256.Sum256(tamperedMessage)
	err = rsa.VerifyPSS(publicKey, crypto.SHA256, tamperedHash[:], signature, nil)
	if err != nil {
		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
49
50
51
52
53
54
55
56
57
58

package main

import (
	"crypto"
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha256"
	"fmt"
	"log"
)

// SignMessage 对消息进行 PSS 签名
func SignMessage(message []byte, privateKey *rsa.PrivateKey) ([]byte, error) {
	// 1. 对消息进行 SHA-256 哈希
	hashed := sha256.Sum256(message)
	// 2. 使用私钥对哈希值进行 PSS 签名
	signature, err := rsa.SignPSS(rand.Reader, privateKey, &rsa.SHA256_PSSParms{}, hashed[:], nil)
	if err != nil {
		return nil, fmt.Errorf("签名失败: %w", err)
	}
	return signature, nil
}

// VerifySignature 验证 PSS 签名
func VerifySignature(message []byte, signature []byte, publicKey *rsa.PublicKey) error {
	// 1. 对消息进行 SHA-256 哈希
	hashed := sha256.Sum256(message)
	// 2. 使用公钥验证签名
	return rsa.VerifyPSS(publicKey, crypto.SHA256, hashed[:], signature, nil)
}

func main() {
	// 生成密钥
	privateKey, _ := rsa.GenerateKey(rand.Reader, 2048)
	publicKey := &privateKey.PublicKey

	// Alice 签发一份电子合同
	contract := []byte("甲方：Alice，乙方：Bob，金额：100万元")
	signature, err := SignMessage(contract, privateKey)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Alice 的签名: %x...\n", signature[:32])

	// Bob 验证签名
	err = VerifySignature(contract, signature, publicKey)
	if err != nil {
		log.Fatalf("签名验证失败: %v", err)
	}
	fmt.Println("✅ Bob 验证通过：这份合同确实是 Alice 签署的！")

	// Eve 试图篡改合同
	tamperedContract := []byte("甲方：Alice，乙方：Eve，金额：1000万元")
	err = VerifySignature(tamperedContract, signature, publicKey)
	if err != nil {
		fmt.Println("✅ Eve 的篡改合同无法通过签名验证！")
	}
}

 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

package main

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

func main() {
	// 方法一：使用指定曲线生成密钥
	// elliptic.P256() 返回 P-256 曲线参数（又称 secp256r1 或 prime256v1）
	privateKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
	if err != nil {
		log.Fatalf("ECDSA 密钥生成失败: %v", err)
	}

	// 打印私钥信息（私钥是敏感数据，仅演示）
	fmt.Printf("私钥算法: %s\n", privateKey.Curve.Params().Name)
	fmt.Printf("私钥 D (十六进制): %x\n", privateKey.D.Text(16))

	// 打印公钥信息
	publicKey := &privateKey.PublicKey
	fmt.Printf("公钥 X (十六进制): %x\n", publicKey.X.Text(16))
	fmt.Printf("公钥 Y (十六进制): %x\n", publicKey.Y.Text(16))

	// 方法二：使用其他曲线
	curves := []elliptic.Curve{
		elliptic.P256(), // P-256, 256 位，约 128 位安全
		elliptic.P384(), // P-384, 384 位，约 192 位安全
		elliptic.P521(), // P-521, 521 位，约 256 位安全
	}

	for _, curve := range curves {
		key, err := ecdsa.GenerateKey(curve, rand.Reader)
		if err != nil {
			log.Fatalf("密钥生成失败: %v", err)
		}
		fmt.Printf("\n曲线 %s:\n", curve.Params().Name)
		fmt.Printf("  私钥位长: %d 位\n", key.D.BitLen())
		fmt.Printf("  公钥位长: %d 位\n", key.PublicKey.X.BitLen())
	}
}

 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/ecdsa"
	"crypto/elliptic"
	"crypto/rand"
	"crypto/rsa"
	"fmt"
)

func main() {
	// RSA vs ECDSA 密钥大小对比
	rsaKey, _ := rsa.GenerateKey(rand.Reader, 2048)
	ecdsaKey, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)

	fmt.Println("┌─────────────────────────────────────────────────┐")
	fmt.Println("│         密钥大小对比 (2048-bit RSA vs P-256)      │")
	fmt.Println("├──────────────────┬──────────────┬──────────────────┤")
	fmt.Printf("│     算法         │   密钥总大小  │     签名大小      │\n")
	fmt.Println("├──────────────────┼──────────────┼──────────────────┤")
	fmt.Printf("│     RSA-2048     │   %4d 字节   │     %4d 字节     │\n",
		(len(rsaKey.N.Bytes())+len(rsaKey.Primes[0].Bytes())+len(rsaKey.Primes[1].Bytes()))/2, 256)
	fmt.Printf("│     ECDSA-P256   │   %4d 字节   │     %4d 字节     │\n",
		(ecdsaKey.X.BitLen()+ecdsaKey.Y.BitLen()+ecdsaKey.D.BitLen())/8, 64)
	fmt.Println("└──────────────────┴──────────────┴──────────────────┘")
	fmt.Println("结论: ECDSA-P256 的密钥和签名都比 RSA-2048 小，但安全性相当！")
}

 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

package main

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

func main() {
	// Step 1: 生成 ECDSA 密钥对（使用 P-256 曲线）
	privateKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
	if err != nil {
		log.Fatalf("密钥生成失败: %v", err)
	}

	// Step 2: 准备要签名的消息
	message := []byte("比特币转账：向 1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa 转账 1 BTC")
	fmt.Printf("消息: %s\n", message)

	// Step 3: 对消息进行哈希（ECDSA 签名的是哈希值，不是原始消息）
	hash := sha256.Sum256(message)
	fmt.Printf("消息哈希: %x\n", hash)

	// Step 4: 使用私钥签名
	// ecdsa.Sign 返回 (r, s) 元组，这是签名的两个值
	r, s, err := ecdsa.Sign(rand.Reader, privateKey, hash[:])
	if err != nil {
		log.Fatalf("签名失败: %v", err)
	}
	// 将签名编码为字节序列（DER 编码或拼接 r||s）
	signature := encodeSignature(r, s)
	fmt.Printf("签名 (r||s 十六进制): %x\n", signature)
	fmt.Printf("签名长度: %d 字节\n", len(signature))

	// Step 5: 使用公钥验证签名
	publicKey := &privateKey.PublicKey
	valid := ecdsa.Verify(publicKey, hash[:], r, s)
	if valid {
		fmt.Println("✅ ECDSA 签名验证成功！")
	} else {
		fmt.Println("❌ ECDSA 签名验证失败！")
	}

	// Step 6: 篡改消息后验证
	tamperedMessage := []byte("比特币转账：向 1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa 转账 10000 BTC")
	tamperedHash := sha256.Sum256(tamperedMessage)
	valid = ecdsa.Verify(publicKey, tamperedHash[:], r, s)
	if !valid {
		fmt.Println("✅ 篡改检测成功！修改后的消息无法通过验证。")
	}
}

// encodeSignature 将 (r, s) 签名值编码为字节切片（r在前，s在后）
func encodeSignature(r, s *big.Int) []byte {
	// 每个分量占 32 字节（对于 P-256）
	rBytes := r.Bytes()
	sBytes := s.Bytes()
	sig := make([]byte, 64)
	// 将 r 和 s 放入签名数组的后部和前部（确保都是 32 字节）
	copy(sig[32-len(rBytes):], rBytes)
	copy(sig[64-len(sBytes):], sBytes)
	return sig
}

 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/ecdsa"
	"crypto/elliptic"
	"crypto/rand"
	"crypto/sha256"
	"crypto/x509"
	"encoding/pem"
	"fmt"
	"log"
	"os"
)

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

	message := []byte("ECDSA 签名演示消息")

	// 签名
	hash := sha256.Sum256(message)
	signature, err := ecdsa.SignASN1(rand.Reader, privateKey, hash[:])
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("DER 编码签名长度: %d 字节\n", len(signature))

	// 验证
	publicKey := &privateKey.PublicKey
	valid := ecdsa.VerifyASN1(publicKey, hash[:], signature)
	fmt.Printf("验证结果: %v\n", valid)

	// 导出私钥为 PEM 格式（实际使用中需要加密存储）
	privBytes, err := x509.MarshalECPrivateKey(privateKey)
	if err != nil {
		log.Fatal(err)
	}
	pemBlock := pem.Block{
		Type:  "EC PRIVATE KEY",
		Bytes: privBytes,
	}
	pem.Encode(os.Stdout, &pemBlock)
}

 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

package main

import (
	"crypto/ecdsa"
	"crypto/elliptic"
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha256"
	"fmt"
	"time"

	"github.com/DavidBelicza/PolySpeed" // 如无此包，可移除
)

func main() {
	// 预热
	_, _ = rsa.GenerateKey(rand.Reader, 2048)
	_, _ = ecdsa.GenerateKey(elliptic.P256(), rand.Reader)

	// RSA 性能测试
	rsaKey, _ := rsa.GenerateKey(rand.Reader, 2048)
	message := []byte("性能测试消息，用于比较 RSA 和 ECDSA 的签名验证速度。")
	hash := sha256.Sum256(message)

	// RSA 签名
	start := time.Now()
	for i := 0; i < 100; i++ {
		_, _ = rsa.SignPSS(rand.Reader, rsaKey, &rsa.SHA256_PSSParms{}, hash[:], nil)
	}
	rsaSignTime := time.Since(start)

	// RSA 验证
	start = time.Now()
	for i := 0; i < 100; i++ {
		sig, _ := rsa.SignPSS(rand.Reader, rsaKey, &rsa.SHA256_PSSParms{}, hash[:], nil)
		_ = rsa.VerifyPSS(&rsaKey.PublicKey, nil, hash[:], sig, nil)
	}
	rsaVerifyTime := time.Since(start)

	// ECDSA 性能测试
	ecdsaKey, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)

	// ECDSA 签名
	start = time.Now()
	for i := 0; i < 100; i++ {
		_, _, _ = ecdsa.Sign(rand.Reader, ecdsaKey, hash[:])
	}
	ecdsaSignTime := time.Since(start)

	// ECDSA 验证
	start = time.Now()
	for i := 0; i < 100; i++ {
		r, s, _ := ecdsa.Sign(rand.Reader, ecdsaKey, hash[:])
		_ = ecdsa.Verify(&ecdsaKey.PublicKey, hash[:], r, s)
	}
	ecdsaVerifyTime := time.Since(start)

	fmt.Println("┌─────────────────────────────────────────────────────┐")
	fmt.Println("│              签名性能对比 (100 次迭代)               │")
	fmt.Println("├────────────────┬──────────────┬──────────────────────┤")
	fmt.Printf("│     算法       │   签名耗时    │     验证耗时         │\n")
	fmt.Println("├────────────────┼──────────────┼──────────────────────┤")
	fmt.Printf("│  RSA-2048 PSS  │  %7.2f ms  │     %7.2f ms        │\n",
		rsaSignTime.Seconds()*1000, rsaVerifyTime.Seconds()*1000)
	fmt.Printf("│  ECDSA-P256    │  %7.2f ms  │     %7.2f ms        │\n",
		ecdsaSignTime.Seconds()*1000, ecdsaVerifyTime.Seconds()*1000)
	fmt.Println("├────────────────┴──────────────┴──────────────────────┤")
	fmt.Printf("│  ECDSA 签名速度提升:   %.1f x                         │\n",
		rsaSignTime.Seconds()/ecdsaSignTime.Seconds())
	fmt.Printf("│  ECDSA 验证速度提升:   %.1f x                         │\n",
		rsaVerifyTime.Seconds()/ecdsaVerifyTime.Seconds())
	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
49
50
51
52
53
54
55
56
57

package main

import (
	"crypto/ed25519"
	"crypto/rand"
	"fmt"
	"log"
)

func main() {
	// Step 1: 生成 Ed25519 密钥对
	// Ed25519 的密钥生成非常简洁：公钥和私钥一起生成
	// Go 1.20+ 支持直接使用 ed25519.GenerateKey()
	publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader)
	if err != nil {
		log.Fatalf("Ed25519 密钥生成失败: %v", err)
	}

	// 打印密钥信息
	fmt.Printf("Ed25519 公钥长度: %d 字节\n", len(publicKey))   // 32 字节
	fmt.Printf("Ed25519 私钥长度: %d 字节\n", len(privateKey))  // 64 字节
	fmt.Printf("公钥 (十六进制): %x\n", publicKey)

	// Step 2: 签名消息
	message := []byte("这是一条需要防篡改的重要消息。")
	fmt.Printf("\n原文: %s\n", message)

	// Ed25519 签名是确定性的：相同消息 + 相同私钥 = 相同签名
	// 不需要随机数！这是一个巨大的安全改进
	signature := ed25519.Sign(privateKey, message)
	fmt.Printf("签名: %x\n", signature)
	fmt.Printf("签名长度: %d 字节\n", len(signature)) // 64 字节

	// Step 3: 验证签名
	// 任何人都可以用公钥验证签名
	valid := ed25519.Verify(publicKey, message, signature)
	if valid {
		fmt.Println("✅ Ed25519 签名验证成功！")
	} else {
		fmt.Println("❌ Ed25519 签名验证失败！")
	}

	// Step 4: 验证确定性（相同消息+私钥产生相同签名）
	signature2 := ed25519.Sign(privateKey, message)
	if string(signature) == string(signature2) {
		fmt.Println("✅ 签名是确定性的：相同消息产生相同签名。")
	} else {
		fmt.Println("❌ 签名不是确定性的（这不应该发生！）")
	}

	// Step 5: 篡改检测
	tamperedMessage := []byte("这是一条被篡改的消息！")
	valid = ed25519.Verify(publicKey, tamperedMessage, signature)
	if !valid {
		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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

package main

import (
	"crypto/ed25519"
	"crypto/ecdsa"
	"crypto/elliptic"
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha256"
	"fmt"
	"time"
)

func main() {
	// 生成各算法的密钥
	_, _ = rsa.GenerateKey(rand.Reader, 2048)
	_, _ = ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
	edPub, edPriv, _ := ed25519.GenerateKey(rand.Reader)
	_ = edPub
	_ = edPriv

	message := []byte("性能测试消息")
	hash := sha256.Sum256(message)

	// 预热
	for i := 0; i < 1000; i++ {
		_, _, _ = ecdsa.Sign(rand.Reader, &ecdsa.PrivateKey{}, hash[:])
		ed25519.Sign(&ed25519.PrivateKey{}, message)
	}

	// 性能测试
	iterations := 1000

	// RSA
	rsaKey, _ := rsa.GenerateKey(rand.Reader, 2048)
	start := time.Now()
	for i := 0; i < iterations; i++ {
		_, _ = rsa.SignPSS(rand.Reader, rsaKey, &rsa.SHA256_PSSParms{}, hash[:], nil)
	}
	rsaTime := float64(time.Since(start).Microseconds()) / float64(iterations)

	// ECDSA
	ecdsaKey, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
	start = time.Now()
	for i := 0; i < iterations; i++ {
		_, _, _ = ecdsa.Sign(rand.Reader, ecdsaKey, hash[:])
	}
	ecdsaTime := float64(time.Since(start).Microseconds()) / float64(iterations)

	// Ed25519
	start = time.Now()
	for i := 0; i < iterations; i++ {
		ed25519.Sign(edPriv, message)
	}
	ed25519Time := float64(time.Since(start).Microseconds()) / float64(iterations)

	fmt.Println("┌─────────────────────────────────────────────────────────┐")
	fmt.Println("│            现代签名算法性能对比 (微秒/签名)               │")
	fmt.Println("├─────────────┬──────────────┬──────────────┬──────────────┤")
	fmt.Printf("│    算法      │  签名 (μs)   │   签名大小   │   密钥大小   │\n")
	fmt.Println("├─────────────┼──────────────┼──────────────┼──────────────┤")
	fmt.Printf("│ RSA-2048    │   %6.1f     │    256 B    │   256 B     │\n", rsaTime)
	fmt.Printf("│ ECDSA-P256  │   %6.1f     │     64 B    │    32 B     │\n", ecdsaTime)
	fmt.Printf("│ Ed25519     │   %6.1f     │     64 B    │    32 B     │\n", ed25519Time)
	fmt.Println("├─────────────┴──────────────┴──────────────┴──────────────┤")
	fmt.Println("│  🏆 结论：Ed25519 是签名最快、密钥最小的现代算法！          │")
	fmt.Println("│  💡 推荐：新项目首选 Ed25519                               │")
	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

package main

import (
	"crypto/ecdh"
	"crypto/rand"
	"fmt"
	"log"
)

func main() {
	// Step 1: 生成 ECDH 私钥
	// ecdh.P256() 指定使用 P-256 曲线（ NIST 曲线之一）
	// Go 支持三种曲线：P256(), P384(), P521()
	privateKey, err := ecdh.P256().GeneratePrivateKey(rand.Reader)
	if err != nil {
		log.Fatalf("ECDH 私钥生成失败: %v", err)
	}

	// Step 2: 从私钥获取公钥
	publicKey := privateKey.PublicKey()

	// Step 3: 查看密钥信息
	fmt.Printf("私钥类型: %s\n", privateKey.Curve())
	fmt.Printf("私钥长度: %d 字节\n", len(privateKey.Bytes()))
	fmt.Printf("公钥类型: %s\n", publicKey.Curve())
	fmt.Printf("公钥长度: %d 字节\n", len(publicKey.Bytes()))

	// Step 4: 导出公钥字节（用于发送给通信对方）
	publicKeyBytes, err := publicKey.Bytes()
	if err != nil {
		log.Fatalf("公钥导出失败: %v", err)
	}
	fmt.Printf("公钥字节: %x\n", publicKeyBytes)

	// Step 5: 从字节恢复公钥（接收对方的公钥时使用）
	// 注意：ecdh 的公钥格式取决于曲线
	// P-256: 未压缩格式 (0x04 || X || Y) 或压缩格式 (0x02/0x03 || X)
	// 接收时需要知道曲线类型
	curve := ecdh.P256()
	restoredPublicKey, err := curve.NewPublicKey(publicKeyBytes)
	if err != nil {
		log.Fatalf("公钥恢复失败: %v", err)
	}
	fmt.Printf("公钥恢复成功: %v\n", restoredPublicKey != nil)
}

 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/ecdh"
	"crypto/rand"
	"fmt"
)

func main() {
	curves := []struct {
		name  string
		curve ecdh.Curve
	}{
		{"P-256", ecdh.P256()},
		{"P-384", ecdh.P384()},
		{"P-521", ecdh.P521()},
	}

	fmt.Println("Go 标准库支持的 ECDH 曲线:")
	fmt.Println("┌─────────────────────────────────────────────────────────┐")
	fmt.Println("│  曲线      │  私钥大小  │  公钥大小（未压缩）│  安全等级 │")
	fmt.Println("├───────────┼────────────┼─────────────────────┼──────────┤")

	for _, c := range curves {
		priv, _ := c.curve.GeneratePrivateKey(rand.Reader)
		pub := priv.PublicKey()
		fmt.Printf("│  %-8s │  %2d 字节   │       %2d 字节        │  %3d 位  │\n",
			c.name, len(priv.Bytes()), len(pub.Bytes()), priv.Curve().Params().BitSize)
	}
	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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

package main

import (
	"crypto/ecdh"
	"crypto/rand"
	"fmt"
	"log"
)

func main() {
	// ==================== 模拟 Alice 和 Bob 的 ECDH 交换 ====================

	// Step 1: Alice 生成 ECDH 密钥对
	alicePrivateKey, err := ecdh.P256().GeneratePrivateKey(rand.Reader)
	if err != nil {
		log.Fatalf("Alice 密钥生成失败: %v", err)
	}
	alicePublicKey := alicePrivateKey.PublicKey()

	// Step 2: Bob 生成 ECDH 密钥对
	bobPrivateKey, err := ecdh.P256().GeneratePrivateKey(rand.Reader)
	if err != nil {
		log.Fatalf("Bob 密钥生成失败: %v", err)
	}
	bobPublicKey := bobPrivateKey.PublicKey()

	// Step 3: Alice 和 Bob 交换公钥（在线下或通过不安全渠道）
	// 在真实场景中，这些字节会通过网络发送
	aliceReceivesBobPublicKeyBytes, err := bobPublicKey.Bytes()
	if err != nil {
		log.Fatalf("Bob 公钥序列化失败: %v", err)
	}
	bobReceivesAlicePublicKeyBytes, err := alicePublicKey.Bytes()
	if err != nil {
		log.Fatalf("Alice 公钥序列化失败: %v", err)
	}

	fmt.Printf("Alice 发送公钥给 Bob: %x...\n", bobReceivesAlicePublicKeyBytes[:16])
	fmt.Printf("Bob   发送公钥给 Alice: %x...\n", aliceReceivesBobPublicKeyBytes[:16])

	// Step 4: Alice 和 Bob 各自用对方的公钥计算共享密钥
	// Alice 用自己的私钥 + Bob 的公钥
	aliceSharedSecret, err := alicePrivateKey.ECDH(bobPublicKey)
	if err != nil {
		log.Fatalf("Alice ECDH 计算失败: %v", err)
	}

	// Bob 用自己的私钥 + Alice 的公钥
	bobSharedSecret, err := bobPrivateKey.ECDH(alicePublicKey)
	if err != nil {
		log.Fatalf("Bob ECDH 计算失败: %v", err)
	}

	// Step 5: 验证双方得到相同的共享密钥
	fmt.Printf("\nAlice 计算的共享密钥: %x\n", aliceSharedSecret)
	fmt.Printf("Bob   计算的共享密钥: %x\n", bobSharedSecret)

	if string(aliceSharedSecret) == string(bobSharedSecret) {
		fmt.Println("✅ ECDH 密钥交换成功！双方拥有相同的共享密钥。")
	} else {
		fmt.Println("❌ 密钥不匹配！")
	}

	// Step 6: 从共享密钥派生出实际的对称密钥
	// 通常使用 HKDF（HMAC-based Key Derivation Function）
	// 这里简化处理，直接用共享密钥的前 32 字节作为 AES-256 密钥
	if len(aliceSharedSecret) >= 32 {
		aesKey := aliceSharedSecret[:32]
		fmt.Printf("\n派生的 AES-256 对称密钥: %x\n", aesKey)
		fmt.Println("现在 Alice 和 Bob 可以用这个对称密钥进行加密通信了！🔐")
	}
}

 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

package main

import (
	"crypto/ecdh"
	"crypto/rand"
	"crypto/sha256"
	"fmt"
	"log"

	"golang.org/x/crypto/chacha20poly1305"
)

func deriveKey(sharedSecret []byte, info string) []byte {
	// 简化版 HKDF：用 HMAC-SHA256 派生密钥
	// 真实场景应使用 crypto/hkdf 包
	h := sha256.New()
	h.Write(sharedSecret)
	h.Write([]byte(info))
	return h.Sum(nil)[:32] // 32 字节用于 AES-256
}

func main() {
	// 模拟 Alice 和 Bob 建立安全通道

	// 1. Alice 生成 ECDH 密钥对
	alicePrivate, _ := ecdh.P256().GeneratePrivateKey(rand.Reader)
	alicePublic := alicePrivate.PublicKey()

	// 2. Bob 生成 ECDH 密钥对
	bobPrivate, _ := ecdh.P256().GeneratePrivateKey(rand.Reader)
	bobPublic := bobPrivate.PublicKey()

	// 3. 交换公钥并计算共享密钥
	aliceShared, _ := alicePrivate.ECDH(bobPublic)
	bobShared, _ := bobPrivate.ECDH(alicePublic)

	// 4. 派生对称密钥
	aliceAESKey := deriveKey(aliceShared, "secure-message")
	bobAESKey := deriveKey(bobShared, "secure-message")

	// 验证双方得到相同的 AES 密钥
	if string(aliceAESKey) != string(bobAESKey) {
		log.Fatal("密钥派生失败")
	}

	// 5. Alice 用 ChaCha20-Poly1305 加密消息
	aead, _ := chacha20poly1305.New(aliceAESKey)
	nonce := make([]byte, aead.NonceSize(), aead.NonceSize()+len("你好 Bob！")+aead.Overhead())
	rand.Read(nonce)
	ciphertext := aead.Seal(nonce, nonce, []byte("你好 Bob！"), nil)

	fmt.Printf("加密后的密文: %x\n", ciphertext)

	// 6. Bob 解密消息
	receivedNonce := ciphertext[:aead.NonceSize()]
	receivedCiphertext := ciphertext[aead.NonceSize():]
	plaintext, err := aead.Open(nil, receivedNonce, receivedCiphertext, nil)
	if err != nil {
		log.Fatalf("解密失败: %v", err)
	}

	fmt.Printf("Bob 解密得到: %s\n", plaintext)
	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

//go:build go1.26 && mlkem

package main

import (
	"crypto/mlkem"
	"fmt"
)

func main() {
	// ML-KEM-768 是目前推荐的参数（相当于 192 位安全）
	// 还有 ML-KEM-512（128 位安全）和 ML-KEM-1024（256 位安全）
	seed := make([]byte, mlkem.MLKEM768.SeedSize())
	// 填充 seed 后生成密钥

	privKey := mlkem.NewMLKEM768(seed)
	publicKey := privKey.Public().(*mlkem.PublicKey)

	// 封装：生成密文和共享密钥
	ciphertext, sharedSecret, _ := publicKey.Encapsulate()
	fmt.Printf("密文长度: %d 字节\n", len(ciphertext))
	fmt.Printf("共享密钥长度: %d 字节\n", len(sharedSecret))

	// 解封：用私钥解封装得到相同的共享密钥
	decryptedSecret := privKey.Decapsulate(ciphertext)
	if string(sharedSecret) == string(decryptedSecret) {
		fmt.Println("✅ ML-KEM 密钥封装/解封装成功！")
	}
}

 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

package main

import (
	"crypto/ecdsa"
	"crypto/elliptic"
	"crypto/ed25519"
	"crypto/rand"
	"crypto/rsa"
	"fmt"
	"log"
	"os"
)

/*
密钥管理检查清单：

1. ✅ 永远使用标准库
   - Go 的 crypto 包经过严格审计
   - 不要使用来历不明的第三方加密库

2. ✅ 选择安全的参数
   - RSA: 至少 2048 位（推荐 3072 或 4096）
   - ECDSA: P-256、P-384 或 P-521
   - Ed25519: 直接使用，默认就是安全的

3. ✅ 私钥存储
   - 私钥文件权限设置为 0600（仅所有者可读写）
   - 考虑使用硬件安全模块（HSM）或 KMS
   - 永远不要把私钥硬编码在代码里！

4. ✅ 密钥轮换
   - 定期更换长期密钥
   - 使用前向安全的临时密钥（ECDHE）

5. ✅ 安全的随机数
   - crypto/rand.Reader 是你的好朋友
   - 不要使用 math/rand 或时间戳作为随机源
*/

func main() {
	fmt.Println("┌─────────────────────────────────────────────────────────┐")
	fmt.Println("│              密钥管理最佳实践清单                         │")
	fmt.Println("├─────────────────────────────────────────────────────────┤")
	fmt.Println("│  ✅ 1. 使用 Go 标准库 crypto 包                          │")
	fmt.Println("│  ✅ 2. RSA 至少 2048 位，推荐 3072/4096 位               │")
	fmt.Println("│  ✅ 3. 新项目优先使用 Ed25519                            │")
	fmt.Println("│  ✅ 4. 私钥文件权限设为 0600                            │")
	fmt.Println("│  ✅ 5. 使用 crypto/rand.Reader 获取随机数                │")
	fmt.Println("│  ✅ 6. 永远不要硬编码私钥                               │")
	fmt.Println("│  ✅ 7. 考虑使用 HSM/KMS 存储私钥                        │")
	fmt.Println("│  ✅ 8. 定期轮换长期密钥                                 │")
	fmt.Println("└─────────────────────────────────────────────────────────┘")

	// 演示正确的密钥生成
	fmt.Println("\n正确做法示例：")

	// Ed25519 - 简单安全
	_, priv, _ := ed25519.GenerateKey(rand.Reader)
	fmt.Printf("Ed25519 私钥长度: %d 字节（直接使用即可）\n", len(priv))

	// ECDSA P-256 - 需要手动管理
	ecdsaKey, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
	fmt.Printf("ECDSA-P256 私钥位数: %d 位（推荐使用）\n", ecdsaKey.D.BitLen())

	// RSA - 需要更大的密钥
	rsaKey, _ := rsa.GenerateKey(rand.Reader, 3072)
	fmt.Printf("RSA-3072 私钥位数: %d 位（较安全）\n", rsaKey.N.BitLen())

	// 错误做法演示
	fmt.Println("\n❌ 错误做法（请勿模仿）：")
	fmt.Println("❌ const mySecretKey = \"123456\"  // 硬编码密钥")
	fmt.Println("❌ 使用 math/rand.New(42)        // 可预测的随机数")
	fmt.Println("❌ 自己实现 AES 加密算法          // 容易出错")

	// 设置私钥文件权限（Unix 系统）
	// if err := os.Chmod("private.key", 0600); err != nil {
	//     log.Fatal(err)
	// }
	_ = os.Chmod
	_ = log.Fatal
}