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

package main

import (
	"crypto/tls"
	"fmt"
	"net/http"
)

func main() {
	// 创建一个默认的 TLS 配置
	config := &tls.Config{
		MinVersion: tls.VersionTLS12, // 至少使用 TLS 1.2
	}

	// 创建一个 HTTPS 服务器
	server := &http.Server{
		Addr:      ":8443",
		TLSConfig: config,
	}

	fmt.Println("HTTPS 服务器准备就绪，监听 8443 端口")
	fmt.Println("（想象一下它在说：'有本事来抓我呀，我可是加密的！'）")

	// server.ListenAndServeTLS("cert.pem", "key.pem")
	_ = server
}

 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 (
	"crypto/tls"
	"crypto/x509"
	"fmt"
	"net/http"
	"strings"
)

func main() {
	// 模拟 TLS 握手中的证书验证
	certPool := x509.NewCertPool()
	// certPool.AppendCertsFromPEM(caCertPEM) // 添加可信 CA 证书

	// 创建一个自定义的 HTTP 客户端
	client := &http.Client{
		Transport: &http.Transport{
			TLSClientConfig: &tls.Config{
				RootCAs:            certPool,              // 可信的 CA 证书池
				ServerName:         "example.com",         // 验证的域名
				InsecureSkipVerify: false,                  // 是否跳过证书验证（生产环境千万别开！）
			},
		},
	}

	fmt.Println("TLS 握手模拟器已启动")
	fmt.Println("正在验证证书链...")
	fmt.Println("正在协商对称密钥...")

	// 模拟验证过程
	verifyProcess := []string{
		"1. 检查证书是否过期...",
		"2. 检查颁发者是否是可信 CA...",
		"3. 检查域名是否匹配...",
		"4. 验证证书签名...",
		"5. 协商出对称密钥 🔐",
	}

	for _, step := range verifyProcess {
		fmt.Printf("   [%s]\n", step)
	}

	fmt.Println("\n握手完成！接下来所有通信都会加密")
	fmt.Println("\n⚠️  生产环境警示：InsecureSkipVerify = false 是正确的！")
	fmt.Println("   只有在本地测试时才能临时设为 true，且用完要马上改回来！")
	_ = client
}

 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

type Config struct {
	// 最小和最大协议版本
	MinVersion uint16
	MaxVersion uint16

	// 证书配置（服务端必需）
	Certificates []Certificate

	// 证书验证相关
	RootCAs      *x509.CertPool // 可信的 CA 证书池
	ClientCAs    *x509.CertPool // 客户端 CA 证书池（mTLS 用）
	ClientAuth   ClientAuthType // 客户端认证类型

	// 服务器名称验证
	ServerName string

	// 密码套件偏好
	CipherSuites []uint16

	// 时间函数（可自定义，常用于测试）
	Time func() time.Time

	// 握手超时
	HandshakeTimeout time.Duration

	// ... 还有更多字段
}

 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

package main

import (
	"crypto/tls"
	"crypto/x509"
	"fmt"
	"net/http"
	"time"
)

func createTLSConfig() *tls.Config {
	return &tls.Config{
		// 协议版本：TLS 1.2 和 1.3 是主流
		MinVersion: tls.VersionTLS12, // 至少 TLS 1.2
		MaxVersion: tls.VersionTLS13, // 最高 TLS 1.3

		// 密码套件：按优先级排序（TLS 1.3 只需要指定这几个）
		CipherSuites: []uint16{
			tls.TLS_AES_128_GCM_SHA256,
			tls.TLS_AES_256_GCM_SHA384,
			tls.TLS_CHACHA20_POLY1305_SHA256,
			// TLS 1.2 及以下的（已不推荐）
			tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
			tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
		},

		// 安全选项
		PreferServerCipherSuites: true, // 服务器决定用哪个密码套件
		SessionTicketsDisabled:    false,
		// MinVerifyChainCodeLen 不是 tls.Config 的有效字段，此处删除
		// 如需验证证书链长度，应使用 tls.Config.VerifyPeerCertificate 回调

		// 客户端认证（服务端配置）
		ClientAuth: tls.NoClientCert, // mTLS 时改为 RequireAndVerifyClientCert

		// 证书验证
		RootCAs: nil, // 使用系统默认的 CA 池

		// 服务器名称（客户端配置）
		ServerName: "example.com", // 用于验证证书 SAN

		// 超时配置
		HandshakeTimeout: 30 * time.Second,

		// 时间函数（可自定义，用于测试）
		Time: time.Now,
	}
}

func main() {
	config := createTLSConfig()

	fmt.Println("TLS 配置创建成功！配置详情：")
	fmt.Printf("  协议版本: TLS 1.2 - TLS 1.3\n")
	fmt.Printf("  密码套件数量: %d\n", len(config.CipherSuites))
	fmt.Printf("  服务器优先选择密码套件: %v\n", config.PreferServerCipherSuites)
	fmt.Printf("  握手超时: %v\n", config.HandshakeTimeout)

	fmt.Println("\n📝 提示：生产环境推荐使用 TLS 1.3，并禁用 TLS 1.2 及以下版本")
	fmt.Println("   MinVersion: tls.VersionTLS13")

	// 创建一个使用此配置的 HTTPS 服务器
	server := &http.Server{
		Addr:      ":8443",
		TLSConfig: config,
	}

	fmt.Printf("\n服务器已配置完成，准备监听 :8443\n")
	fmt.Printf("（想象它穿着定制西装，帅气逼人）\n")
	_ = server
}

1

func Dial(network, addr string, config *Config) (*Conn, 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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

package main

import (
	"crypto/tls"
	"fmt"
	"io"
	"log"
	"net"
)

func main() {
	fmt.Println("📞 正在拨打加密电话...")

	// 方法一：直接拨号（最简单）
	config := &tls.Config{
		ServerName: "example.com",
	}

	conn, err := tls.Dial("tcp", "93.184.216.34:443", config)
	if err != nil {
		log.Fatalf("拨号失败: %v", err)
	}
	defer conn.Close()

	fmt.Println("✅ 连接建立成功！")
	fmt.Printf("   本地地址: %s\n", conn.LocalAddr())
	fmt.Printf("   远程地址: %s\n", conn.RemoteAddr())
	fmt.Printf("   使用的 TLS 版本: %s\n", tlsVersionToString(conn.ConnectionState().Version))
	fmt.Printf("   使用的密码套件: %s\n", cipherSuiteToString(conn.ConnectionState().CipherSuite))

	// 发送 HTTP 请求
	fmt.Println("\n📤 发送 HTTPS 请求...")
	conn.Write([]byte("GET / HTTP/1.0\r\n\r\n")) // 发送请求

	// 读取响应
	buf := make([]byte, 1024)
	n, _ := conn.Read(buf)
	fmt.Printf("\n📥 收到响应（截取前200字节）:\n%s\n", string(buf[:n]))

	fmt.Println("\n🔒 加密通话结束，挂断电话")
}

// 将 TLS 版本号转为可读字符串
func tlsVersionToString(v uint16) string {
	switch v {
	case tls.VersionTLS10:
		return "TLS 1.0"
	case tls.VersionTLS11:
		return "TLS 1.1"
	case tls.VersionTLS12:
		return "TLS 1.2"
	case tls.VersionTLS13:
		return "TLS 1.3"
	default:
		return "未知"
	}
}

// 将密码套件 ID 转为可读字符串
func cipherSuiteToString(id uint16) string {
	switch id {
	case tls.TLS_AES_128_GCM_SHA256:
		return "TLS_AES_128_GCM_SHA256 (TLS 1.3)"
	case tls.TLS_AES_256_GCM_SHA384:
		return "TLS_AES_256_GCM_SHA384 (TLS 1.3)"
	case tls.TLS_CHACHA20_POLY1305_SHA256:
		return "TLS_CHACHA20_POLY1305_SHA256 (TLS 1.3)"
	default:
		return fmt.Sprintf("0x%04x", id)
	}
}

 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/tls"
	"fmt"
	"net"
	"net/url"
	"time"
)

func main() {
	// 如果你需要更多控制，可以用 net.Dial + tls.Client 的组合

	fmt.Println("🔧 使用 Dialer 进行精细控制...")

	// 创建一个自定义的 Dialer
	dialer := &net.Dialer{
		Timeout:   30 * time.Second,  // 连接超时
		KeepAlive: 30 * time.Second,  // 保活时间
	}

	// 先建立 TCP 连接
	conn, err := dialer.Dial("tcp", "example.com:443")
	if err != nil {
		fmt.Printf("TCP 连接失败: %v\n", err)
		return
	}
	defer conn.Close()

	// 将 TCP 连接升级为 TLS 连接
	tlsConn := tls.Client(conn, &tls.Config{
		ServerName:         "example.com",
		InsecureSkipVerify: false, // 始终验证证书！
	})

	// 手动触发握手
	err = tlsConn.Handshake()
	if err != nil {
		fmt.Printf("TLS 握手失败: %v\n", err)
		return
	}

	fmt.Println("✅ 手动握手成功！")
	fmt.Printf("   TLS 版本: %x\n", tlsConn.ConnectionState().Version)
	fmt.Printf("   证书 DNS Names: %v\n", tlsConn.ConnectionState().ServerName)

	// 解析 URL 辅助函数示例
	u, _ := url.Parse("https://example.com:8443/path?query=1")
	fmt.Printf("\n📍 URL 解析结果:\n")
	fmt.Printf("   协议: %s\n", u.Scheme)
	fmt.Printf("   主机: %s\n", u.Host)
	fmt.Printf("   路径: %s\n", u.Path)
	fmt.Printf("   端口: %s\n", u.Port())
}

1

func Listen(network, laddr string, config *Config) (*TCPListener, 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
 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
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

package main

import (
	"crypto/rand"
	"crypto/rsa"
	"crypto/tls"
	"crypto/x509"
	"crypto/x509/pkix"
	"encoding/pem"
	"fmt"
	"math/big"
	"net"
	"time"
)

// 生成自签名证书（仅用于测试！）
func generateSelfSignedCert() (tls.Certificate, error) {
	// 生成 RSA 私钥
	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
	if err != nil {
		return tls.Certificate{}, err
	}

	// 创建证书模板
	template := x509.Certificate{
		SerialNumber: big.NewInt(1),
		Subject: pkix.Name{
			Organization: []string{"测试组织"},
			CommonName:   "localhost",
		},
		NotBefore:             time.Now,
		NotAfter:              time.Now().Add(365 * 24 * time.Hour),
		KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
		BasicConstraintsValid: true,
		IsCA:                  false,
		DNSNames:              []string{"localhost", "127.0.0.1"},
	}

	// 自签名
	certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, &privateKey.PublicKey, privateKey)
	if err != nil {
		return tls.Certificate{}, err
	}

	// 编码为 PEM
	certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER})
	keyPEM := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(privateKey)})

	return tls.X509KeyPair(certPEM, keyPEM)
}

func main() {
	fmt.Println("🏢 正在开设加密酒店...")

	// 生成测试证书
	cert, err := generateSelfSignedCert()
	if err != nil {
		fmt.Printf("证书生成失败: %v\n", err)
		return
	}

	// 创建 TLS 配置
	config := &tls.Config{
		Certificates: []tls.Certificate{cert},
		MinVersion:   tls.VersionTLS12,
	}

	// 创建 TLS 监听器
	listener, err := tls.Listen("tcp", ":8443", config)
	if err != nil {
		fmt.Printf("监听失败: %v\n", err)
		return
	}

	fmt.Printf("✅ TLS 监听器创建成功！\n")
	fmt.Printf("   监听地址: %s\n", listener.Addr())
	fmt.Printf("   协议: TLS 1.2+\n")

	// 在后台接受连接
	go func() {
		fmt.Println("\n📞 等待客户端连接...")
		for {
			conn, err := listener.Accept()
			if err != nil {
				fmt.Printf("接受连接失败: %v\n", err)
				continue
			}

			go handleConnection(conn)
		}
	}()

	// 模拟等待一段时间
	time.Sleep(2 * time.Second)
	fmt.Println("\n👋 服务端设置完成，正在监听 :8443")
	fmt.Println("（想象它戴着耳机说：'您好，加密客服为您服务'）")

	// 实际使用中不要 close
	// listener.Close()
}

func handleConnection(conn net.Conn) {
	defer conn.Close()

	tlsConn, ok := conn.(*tls.Conn)
	if !ok {
		fmt.Println("类型转换失败")
		return
	}

	// 获取连接状态
	state := tlsConn.ConnectionState()
	fmt.Printf("\n📱 收到连接！\n")
	fmt.Printf("   客户端 IP: %s\n", conn.RemoteAddr())
	fmt.Printf("   TLS 版本: %x\n", state.Version)
	fmt.Printf("   握手完成: %v\n", state.HandshakeComplete)

	// 简单响应
	response := "HTTP/1.0 200 OK\r\n\r\nHello, TLS World!"
	conn.Write([]byte(response))
}

 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

package main

import (
	"crypto/tls"
	"fmt"
	"net/http"
	"time"
)

func main() {
	// 创建自定义的 TLS 配置
	config := &tls.Config{
		MinVersion: tls.VersionTLS12,
		// MaxVersion: tls.VersionTLS13,
	}

	// 创建 HTTP 服务器
	server := &http.Server{
		Addr:      ":8443",
		TLSConfig: config,
		Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			fmt.Fprintf(w, "Hello, TLS World! 你好，加密世界！")
		}),
	}

	fmt.Println("🚀 HTTPS 服务器准备启动...")
	fmt.Println("   传统方式: server.ListenAndServeTLS(certFile, keyFile)")
	fmt.Println("   程序化方式: 需要手动加载证书并配置 tls.Config.Certificates")

	// 启动服务器（需要先有证书文件）
	// go server.ListenAndServeTLS("cert.pem", "key.pem")

	fmt.Println("\n📝 提示：生产环境使用 Let's Encrypt 自动获取证书")
	fmt.Println("   推荐库: golang.org/x/crypto/acme/autocert")

	// 模拟
	time.Sleep(1 * time.Second)
	fmt.Println("\n（服务器在心里默默说：'随时准备接受加密连接'）")
}

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

// 简化版结构
type Conn struct {
	// 嵌入 Reader 和 Writer 功能
	net.Conn
}

// 连接状态
type ConnectionState struct {
	Version                    uint16              // TLS 版本，如 0x0304 (TLS 1.3)
	CipherSuite                uint16              // 密码套件 ID
	HandshakeComplete          bool                // 握手是否完成
	DidResume                  bool                // 是否恢复了会话
	ServerName                 string              // 服务器名称
	PeerCertificates           []*x509.Certificate // 对端的证书链
	VerifiedChains             [][]*x509.Certificate // 验证通过的证书链
	SignedCertificateTimestamps [][]byte           // SCT 信息
	OCSPResponse               []byte              // OCSP 响应
	TLSUnique                  []byte              // 握手的 unique 标签
}

  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
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

package main

import (
	"crypto/tls"
	"fmt"
	"io"
	"net"
	"time"
)

func main() {
	// 创建监听器（简化版，跳过证书生成）
	config := &tls.Config{
		MinVersion: tls.VersionTLS12,
		// Certificates 需要配置，实际运行时请先加载证书
	}

	// 模拟监听（实际需要真实证书）
	fmt.Println("🔌 TLS 连接生命周期演示")
	fmt.Println("\n=== 连接状态流转 ===")

	// 创建一个模拟的连接状态展示
	states := []struct {
		name string
		fn   string
	}{
		{"初始化", "conn := tls.Client(rawConn, config)"},
		{"握手中", "err := conn.Handshake()"},
		{"已连接", "conn.Read() / conn.Write()"},
		{"关闭中", "conn.Close()"},
	}

	for i, s := range states {
		arrow := "→"
		if i == 0 {
			arrow = "●"
		}
		fmt.Printf("  %s %s\n", arrow, s.name)
		fmt.Printf("     代码: %s\n", s.fn)
	}

	fmt.Println("\n=== 读写操作详解 ===")

	// 注意：以下代码仅用于展示 API 用法，实际运行需要完整的服务器/客户端
	fmt.Println(`
// 握手
conn, err := tls.Client(rawConn, config)
if err != nil {
    return err
}
err = conn.Handshake()
if err != nil {
    return err
}

// 读取数据（会自动解密）
data := make([]byte, 1024)
n, err := conn.Read(data)

// 写入数据（会自动加密）
_, err = conn.Write([]byte("Hello, TLS!"))

// 关闭连接
conn.Close()
`)

	fmt.Println("=== 实际连接示例 ===")

	// 创建一个简单的 echo 服务器演示
	go func() {
		// 监听本地端口（使用 tls.Listen 需要证书，这里演示概念）
		ln, err := net.Listen("tcp", ":18443")
		if err != nil {
			fmt.Printf("监听失败: %v\n", err)
			return
		}
		defer ln.Close()

		fmt.Println("   [Echo 服务器] 已启动，监听 :18443")

		conn, err := ln.Accept()
		if err != nil {
			return
		}
		defer conn.Close()

		// 简单 echo
		buf := make([]byte, 1024)
		n, _ := conn.Read(buf)
		conn.Write(buf[:n])
	}()

	time.Sleep(100 * time.Millisecond)

	// 模拟客户端连接
	conn, err := net.Dial("tcp", "127.0.0.1:18443")
	if err != nil {
		fmt.Printf("连接失败: %v\n", err)
		return
	}
	defer conn.Close()

	fmt.Println("   [Echo 客户端] 已连接")

	// 发送数据
	msg := []byte("Hello, TLS Echo!")
	n, err := conn.Write(msg)
	fmt.Printf("   [Echo 客户端] 发送了 %d 字节: %s\n", n, msg)

	// 接收响应
	buf := make([]byte, 1024)
	n, err = conn.Read(buf)
	fmt.Printf("   [Echo 客户端] 收到 %d 字节: %s\n", n, string(buf[:n]))

	fmt.Println("\n📝 提示：真实 TLS 连接需要证书配置，这里是普通 TCP 演示")
	fmt.Println("   真实的 tls.Conn 会自动处理加密/解密，API 接口类似 net.Conn")
}

1
2
3
4
5
6
7
8

// TLS 1.3 只有这 5 个密码套件
const (
	TLS_AES_128_GCM_SHA256       = 0x1301
	TLS_AES_256_GCM_SHA384       = 0x1302
	TLS_CHACHA20_POLY1305_SHA256 = 0x1303
	TLS_AES_128_CCM_SHA256       = 0x1304
	TLS_AES_128_CCM_8_SHA256     = 0x1305
)

 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
86
87
88
89
90
91
92
93
94
95
96

package main

import (
	"crypto/tls"
	"fmt"
)

func main() {
	fmt.Println("🔐 TLS 版本特性对比")
	fmt.Println("\n=== TLS 1.3 新特性 ===")

	features := []struct {
		name        string
		tls12       string
		tls13       string
		description string
	}{
		{
			name:        "握手时间",
			tls12:       "1-RTT (简化后)",
			tls13:       "1-RTT 或 0-RTT",
			description: "TLS 1.3 简化了握手流程",
		},
		{
			name:        "0-RTT",
			tls12:       "不支持",
			tls13:       "支持",
			description: "恢复会话时立即发送数据，适合 HTTP/2",
		},
		{
			name:        "前向保密",
			tls12:       "可选 (ECDHE)",
			tls13:       "必须",
			description: "即使长期密钥泄露，历史通信仍安全",
		},
		{
			name:        "密码套件数量",
			tls12:       "数百种",
			tls13:       "仅 5 种",
			description: "减少配置错误，提高安全性",
		},
		{
			name:        "废弃算法",
			tls12:       "RSA, RC4, 3DES",
			tls13:       "全部移除",
			description: "只保留安全的算法",
		},
	}

	for _, f := range features {
		fmt.Printf("\n📌 %s\n", f.name)
		fmt.Printf("   TLS 1.2: %s\n", f.tls12)
		fmt.Printf("   TLS 1.3: %s\n", f.tls13)
		fmt.Printf("   说明: %s\n", f.description)
	}

	fmt.Println("\n=== 代码配置 ===")

	// TLS 1.3 仅配置
	config13 := &tls.Config{
		MinVersion: tls.VersionTLS13, // 只允许 TLS 1.3
		MaxVersion: tls.VersionTLS13,
	}

	// TLS 1.2 + 1.3 配置
	config12 := &tls.Config{
		MinVersion: tls.VersionTLS12, // 允许 TLS 1.2 和 1.3
		MaxVersion: tls.VersionTLS13,
	}

	fmt.Printf(`
// 只使用 TLS 1.3（推荐）
config := &tls.Config{
    MinVersion: tls.VersionTLS13,
    MaxVersion: tls.VersionTLS13,
}

// 同时支持 TLS 1.2 和 1.3
config := &tls.Config{
    MinVersion: tls.VersionTLS12,
    MaxVersion: tls.VersionTLS13,
}
`)

	fmt.Printf("\n当前配置支持的最大版本: ")
	switch config12.MaxVersion {
	case tls.VersionTLS13:
		fmt.Println("TLS 1.3")
	case tls.VersionTLS12:
		fmt.Println("TLS 1.2")
	}

	fmt.Println("\n⚠️  注意：0-RTT 有重放攻击风险，不适合敏感操作！")
	fmt.Println("   建议仅在对性能要求极高且数据不敏感时使用")
	_ = config13
}

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

type Certificate struct {
	Certificate [][]byte // 证书链，第一个是服务器证书

	// 私钥
	PrivateKey crypto.PrivateKey // 私钥（可以是 *rsa.PrivateKey, *ecdsa.PrivateKey, ed25519.PrivateKey）

	// Leaf 证书（可选，由 crypto/x509 解析）
	Leaf *x509.Certificate

	// OCSP 响应（可选）
	OCSPStaple []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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

package main

import (
	"crypto/rsa"
	"crypto/tls"
	"crypto/x509"
	"encoding/pem"
	"fmt"
	"os"
)

func main() {
	fmt.Println("📜 证书配置示例")
	fmt.Println("\n=== 加载证书的方式 ===")

	// 方式一：直接从文件加载（最常用）
	// cert, err := tls.LoadX509KeyPair("cert.pem", "key.pem")

	// 方式二：从内存加载（需要 PEM 数据）
	// cert, err := tls.X509KeyPair(certPEM, keyPEM)

	// 方式三：程序化生成（用于测试）
	cert := generateTestCertificate()

	fmt.Println("✅ 证书配置完成！")
	fmt.Printf("   证书链长度: %d\n", len(cert.Certificate))
	fmt.Printf("   私钥类型: %T\n", cert.PrivateKey)

	if cert.Leaf != nil {
		fmt.Printf("   主题: %s\n", cert.Leaf.Subject)
		fmt.Printf("   有效期: %s - %s\n",
			cert.Leaf.NotBefore.Format("2006-01-02"),
			cert.Leaf.NotAfter.Format("2006-01-02"))
	}

	fmt.Println("\n=== TLS 配置中的证书 ===")

	config := &tls.Config{
		Certificates: []tls.Certificate{cert},
	}

	fmt.Printf("已配置 %d 个证书\n", len(config.Certificates))
	fmt.Println("（服务端会根据客户端的 SNI 选择对应证书）")

	fmt.Println("\n📝 提示：生产环境证书推荐从 Let's Encrypt 获取")
	fmt.Println("   使用 golang.org/x/crypto/acme/autocert 自动管理")
}

// 生成测试证书（仅用于演示）
func generateTestCertificate() tls.Certificate {
	// 这是一个占位函数，实际使用时需要完整的证书生成逻辑
	// 参见 38.13 x509.CreateCertificate
	return tls.Certificate{
		Certificate: [][]byte{[]byte("mock-cert")},
		PrivateKey:  &rsa.PrivateKey{},
	}
}

func loadCertFromFiles(certFile, keyFile string) (*tls.Certificate, error) {
	// 读取证书文件
	certPEM, err := os.ReadFile(certFile)
	if err != nil {
		return nil, fmt.Errorf("读取证书失败: %w", err)
	}

	keyPEM, err := os.ReadFile(keyFile)
	if err != nil {
		return nil, fmt.Errorf("读取私钥失败: %w", err)
	}

	// 解析证书
	block, _ := pem.Decode(certPEM)
	if block == nil {
		return nil, fmt.Errorf("PEM 解码失败")
	}

	cert, err := x509.ParseCertificate(block.Bytes)
	if err != nil {
		return nil, fmt.Errorf("证书解析失败: %w", err)
	}

	// 解析私钥
	block, _ = pem.Decode(keyPEM)
	if block == nil {
		return nil, fmt.Errorf("私钥 PEM 解码失败")
	}

	key, err := x509.ParsePKCS1PrivateKey(block.Bytes)
	if err != nil {
		return nil, fmt.Errorf("私钥解析失败: %w", err)
	}

	return &tls.Certificate{
		Certificate: [][]byte{certPEM},
		PrivateKey:  key,
		Leaf:        cert,
	}, 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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

package main

import (
	"crypto/tls"
	"fmt"
)

func main() {
	fmt.Println("🌐 多证书配置（SNI 支持）")
	fmt.Println("\n=== 场景 ===")
	fmt.Println("一台服务器托管多个域名：")
	fmt.Println("  - example.com (使用 RSA 证书)")
	fmt.Println("  - example.org (使用 ECDSA 证书)")

	// 配置多个证书
	config := &tls.Config{
		Certificates: []tls.Certificate{
			// 第一个证书（默认）
			// cert1,
			// 第二个证书
			// cert2,
		},
		// 如果需要根据 SNI 动态选择证书，可以设置 GetCertificate 回调
		GetCertificate: func(info *tls.ClientHelloInfo) (*tls.Certificate, error) {
			fmt.Printf("   收到 SNI 请求: %s\n", info.ServerName)

			// 根据 ServerName 返回对应证书
			switch info.ServerName {
			case "example.com":
				return &cert1, nil
			case "example.org":
				return &cert2, nil
			default:
				return &cert1, nil
			}
		},
	}

	fmt.Printf("\n已配置 %d 个证书 + GetCertificate 回调\n", len(config.Certificates))
	fmt.Println("（服务器会根据客户端的 SNI 动态选择证书）")

	fmt.Println("\n📝 提示：SNI 让一台服务器可以服务多个 HTTPS 域名")
	fmt.Println("   这是现代 HTTPS 托管的基础技术")
}

var cert1, cert2 tls.Certificate // 占位

 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/tls"
	"crypto/x509"
	"fmt"
	"net/http"
)

func main() {
	fmt.Println("🔐 mTLS 双向证书认证示例")
	fmt.Println("\n=== 服务端配置 ===")

	// 创建 CA 证书池（用于验证客户端证书）
	clientCertPool := x509.NewCertPool()
	// clientCertPool.AppendCertsFromPEM(caCertPEM)

	// 服务端 mTLS 配置
	serverConfig := &tls.Config{
		// 必须有证书
		Certificates: []tls.Certificate{serverCert},

		// 必须验证客户端证书
		ClientAuth: tls.RequireAndVerifyClientCert,

		// 使用我们指定的 CA 池验证客户端证书
		ClientCAs: clientCertPool,
	}

	fmt.Printf(`
服务端 mTLS 配置:
  ClientAuth: RequireAndVerifyClientCert
  ClientCAs:  CA 证书池（用于验证客户端证书）
  效果: 拒绝任何没有有效证书的客户端连接

// 客户端认证类型选项:
ClientAuth = NoClientCert              // 不要求客户端证书
ClientAuth = RequestClientCert         // 请求证书，但不强制
ClientAuth = RequireAnyClientCert       // 要求证书，但不验证
ClientAuth = VerifyClientCertIfGiven   // 如果提供了则验证
ClientAuth = RequireAndVerifyClientCert // 必须提供且验证通过（最严格）
`)

	// 创建 HTTPS 服务器
	server := &http.Server{
		Addr:      ":8443",
		TLSConfig: serverConfig,
		Handler:   http.HandlerFunc(handler),
	}

	fmt.Printf("\n服务器已配置 mTLS，正在监听 :8443\n")
	fmt.Println("（服务器正在检查每位访客的'工作证'）")

	// 启动服务器
	// go server.ListenAndServeTLS("server.crt", "server.key")

	_ = server
}

func handler(w http.ResponseWriter, r *http.Request) {
	// 获取客户端证书信息
	if r.TLS != nil && len(r.TLS.PeerCertificates) > 0 {
		cert := r.TLS.PeerCertificates[0]
		fmt.Printf("已验证客户端: %s\n", cert.Subject.CommonName)
	}
	w.Write([]byte("mTLS 连接成功！"))
}

var serverCert tls.Certificate // 占位

 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 (
	"crypto/tls"
	"crypto/x509"
	"fmt"
	"net/http"
)

func main() {
	fmt.Println("📱 mTLS 客户端配置示例")

	// 客户端需要加载自己的证书
	clientCert, err := tls.LoadX509KeyPair("client.crt", "client.key")
	if err != nil {
		fmt.Printf("加载客户端证书失败: %v\n", err)
		return
	}

	// 创建客户端 CA 证书池（用于验证服务器证书）
	serverCertPool := x509.NewCertPool()
	// serverCertPool.AppendCertsFromPEM(serverCA)

	// 客户端 mTLS 配置
	clientConfig := &tls.Config{
		Certificates: []tls.Certificate{clientCert}, // 客户端证书
		RootCAs:      serverCertPool,                 // 服务器 CA
		ServerName:   "example.com",                 // 验证服务器域名
	}

	// 创建 HTTP 客户端
	client := &http.Client{
		Transport: &http.Transport{
			TLSClientConfig: clientConfig,
		},
	}

	fmt.Printf(`
客户端 mTLS 配置:
  Certificates: 客户端证书（用于身份认证）
  RootCAs:      服务器 CA（用于验证服务器证书）
  ServerName:   example.com（必须匹配证书 SAN）

成功建立 mTLS 连接！
`)

	_ = client
}

 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 (
	"crypto/x509"
	"fmt"
)

func main() {
	fmt.Println("📜 crypto/x509 包概述")
	fmt.Println("\n=== X.509 证书的功能 ===")

	functions := []struct {
		name    string
		api     string
		desc    string
	}{
		{"解析证书", "x509.ParseCertificate()", "解析 DER 格式证书"},
		{"解析证书请求", "x509.ParseCertificateRequest()", "解析 CSR"},
		{"生成证书", "x509.CreateCertificate()", "创建新证书（需要 CA 签名）"},
		{"验证证书", "Certificate.Verify()", "验证证书链"},
		{"解析 CRL", "x509.ParseRevocationList()", "解析证书吊销列表"},
		{"创建证书请求", "x509.CreateCertificateRequest()", "创建 CSR"},
	}

	for _, f := range functions {
		fmt.Printf("  ✅ %s\n", f.name)
		fmt.Printf("     API: %s\n", f.api)
		fmt.Printf("     说明: %s\n\n", f.desc)
	}

	fmt.Println("=== 证书格式支持 ===")

	formats := []struct {
		format string
		api    string
	}{
		{"DER (二进制)", "x509.ParseCertificate()"},
		{"PEM (Base64)", "先 pem.Decode() 再 x509.ParseCertificate()"},
		{"PKCS#12", "x509.ParsePKCS12()"},
		{"PKCS#7", "x509.ParsePKCS7()"},
	}

	for _, f := range formats {
		fmt.Printf("  📦 %s: %s\n", f.format, f.api)
	}

	fmt.Println("\n📝 提示：浏览器使用 PEM 格式，Go 解析 DER 更高效")
}

1

func ParseCertificate(asn1Data []byte) (*Certificate, 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
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/x509"
	"encoding/pem"
	"fmt"
	"os"
)

func main() {
	fmt.Println("🔓 证书解析示例")

	// 方法一：解析 DER 格式（原始二进制）
	derData := readDERFile("cert.der")
	cert, err := x509.ParseCertificate(derData)
	if err != nil {
		fmt.Printf("DER 解析失败: %v\n", err)
		return
	}

	fmt.Printf("✅ DER 证书解析成功！\n")
	printCertInfo(cert)

	// 方法二：解析 PEM 格式（Base64 编码）
	pemData := readPEMFile("cert.pem")
	block, _ := pem.Decode(pemData)
	if block == nil {
		fmt.Println("PEM 解码失败")
		return
	}

	cert, err = x509.ParseCertificate(block.Bytes)
	if err != nil {
		fmt.Printf("PEM 中的 DER 解析失败: %v\n", err)
		return
	}

	fmt.Printf("\n✅ PEM 证书解析成功！\n")
	printCertInfo(cert)

	_ = os.Args // 占位
}

func printCertInfo(cert *x509.Certificate) {
	fmt.Printf("\n📋 证书信息:\n")
	fmt.Printf("   版本: v%d\n", cert.Version+1) // Version 从 0 开始
	fmt.Printf("   序列号: %s\n", cert.SerialNumber)
	fmt.Printf("   主体: %s\n", cert.Subject)
	fmt.Printf("   颁发者: %s\n", cert.Issuer)
	fmt.Printf("   有效期: %s 至 %s\n",
		cert.NotBefore.Format("2006-01-02"),
		cert.NotAfter.Format("2006-01-02"))

	if len(cert.DNSNames) > 0 {
		fmt.Printf("   DNS 名称: %v\n", cert.DNSNames)
	}
	if len(cert.EmailAddresses) > 0 {
		fmt.Printf("   邮箱: %v\n", cert.EmailAddresses)
	}
	if cert.SubjectKeyId != nil {
		fmt.Printf("   主题密钥ID: %x\n", cert.SubjectKeyId)
	}
}

// 占位函数
func readDERFile(name string) []byte {
	return []byte{}
}

func readPEMFile(name string) []byte {
	return []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

package main

import (
	"crypto/x509"
	"encoding/pem"
	"fmt"
)

func main() {
	fmt.Println("🔄 PEM 和 DER 格式转换")

	// PEM 转 DER
	pemData := `-----BEGIN CERTIFICATE-----
MIIBkTCB+wIJAKHBfpegPjMCMA0GCSqGSIb3DQEBCwUAMBExDzANBgNVBAMMBmV4
YW1wbGUwHhcNMjQwMTAxMDAwMDAwWhcNMjUxMjMxMjM1OTU5WjAWMRQwEgYDVQQD
DAtleGFtcGxlLmNvbTBcMA0GCSqGSIb3DQEBAQUAA0sAMEgCQQC4cnzO2j8S2Y3v
...
-----END CERTIFICATE-----`

	fmt.Println("原始 PEM 数据长度:", len(pemData))

	// PEM 解码
	block, _ := pem.Decode([]byte(pemData))
	if block == nil {
		fmt.Println("PEM 解码失败")
		return
	}

	fmt.Printf("PEM 类型: %s\n", block.Type)
	fmt.Printf("DER 数据长度: %d 字节\n", len(block.Bytes))

	// 解析证书
	cert, err := x509.ParseCertificate(block.Bytes)
	if err != nil {
		fmt.Printf("证书解析失败: %v\n", err)
		return
	}

	fmt.Printf("\n解析成功！\n")
	fmt.Printf("  主体: %s\n", cert.Subject.CommonName)
	fmt.Printf("  有效期至: %s\n", cert.NotAfter.Format("2006-01-02"))

	// DER 转 PEM
	derData := block.Bytes
	pemBlock := pem.Block{
		Type:  "CERTIFICATE",
		Bytes: derData,
	}
	pemOutput := pem.EncodeToMemory(&pemBlock)

	fmt.Printf("\nDER 转 PEM 结果:\n%s", string(pemOutput))
}