crypto/tls - TLS/SSL 加密通信

概述

crypto/tls 包实现了 TLS（Transport Layer Security）协议，用于在网络通信中提供加密和身份验证。

TLS 协议版本：

• ✅ TLS 1.2：广泛支持，推荐使用
• ✅ TLS 1.3：最新标准，最安全，推荐优先使用
• ❌ TLS 1.0/1.1：已弃用，存在安全漏洞
• ❌ SSL 2.0/3.0：已废弃，严重不安全

主要用途：

• 🔐 HTTPS 服务器：安全的 Web 服务
• 🔗 加密 TCP 连接：安全的网络通信
• 🪪 客户端/服务器认证：双向 TLS（mTLS）
• 📦 安全 API 通信：微服务间加密通信

核心类型

1. Config - TLS 配置

type Config struct {
    // 核心字段
    Rand            io.Reader     // 随机数生成器
    Time            func() time.Time // 时间函数
    Certificates    []Certificate // 证书列表
    NameToCertificate map[string]*Certificate // 证书映射
    
    // 根证书和客户端认证
    RootCAs         *x509.CertPool // 根证书池
    ClientCAs       *x509.CertPool // 客户端证书池
    ClientAuth      ClientAuthType // 客户端认证类型
    
    // 协议版本和密码套件
    MinVersion      uint16        // 最低 TLS 版本
    MaxVersion      uint16        // 最高 TLS 版本
    CipherSuites    []uint16      // 密码套件列表
    
    // 回调函数
    GetCertificate  func(*ClientHelloInfo) (*Certificate, error)
    GetClientCertificate func(*CertificateRequestInfo) (*Certificate, error)
    VerifyPeerCertificate func([][]byte, [][]*x509.Certificate) error
    
    // 其他配置
    ServerName      string        // 服务器名称（SNI）
    NextProtos      []string      // ALPN 协议
    InsecureSkipVerify bool       // 跳过验证（仅用于测试）
    
    // ... 更多字段
}

重要字段说明：

证书相关

• Certificates：服务器的证书链
• RootCAs：信任的根证书（客户端使用）
• ClientCAs：信任的客户端证书（服务器使用）
• ClientAuth：客户端认证模式

版本控制

• MinVersion：最低支持的 TLS 版本
• MaxVersion：最高支持的 TLS 版本
• 推荐：MinVersion = VersionTLS12

密码套件

• CipherSuites：允许的密码套件列表
• 应仅包含安全的密码套件

安全选项

• InsecureSkipVerify：跳过证书验证
• ⚠️ 仅用于测试：生产环境绝不使用

2. Conn - TLS 连接

type Conn struct {
    // 包含过滤或未导出的字段
}

功能：表示一个 TLS 连接。

主要方法：

// 握手
func (c *Conn) Handshake() error

// 读写
func (c *Conn) Read(b []byte) (int, error)
func (c *Conn) Write(b []byte) (int, error)
func (c *Conn) Close() error

// 连接信息
func (c *Conn) ConnectionState() ConnectionState
func (c *Conn) NetConn() net.Conn

// 截止时间
func (c *Conn) SetDeadline(t time.Time) error
func (c *Conn) SetReadDeadline(t time.Time) error
func (c *Conn) SetWriteDeadline(t time.Time) error

3. ConnectionState - 连接状态

type ConnectionState struct {
    Version                     uint16           // TLS 版本
    HandshakeComplete           bool             // 握手完成
    DidResume                   bool             // 是否恢复会话
    CipherSuite                 uint16           // 密码套件
    NegotiatedProtocol          string           // ALPN 协议
    ServerName                  string           // 服务器名称
    PeerCertificates            []*x509.Certificate // 对端证书
    VerifiedChains              [][]*x509.Certificate // 验证的证书链
    TLSUnique                   []byte           // TLS 唯一值
    
    // ... 更多字段
}

4. Certificate - 证书

type Certificate struct {
    Certificate [][]byte // 证书链（DER 编码）
    PrivateKey  crypto.PrivateKey // 私钥
    // ... 更多字段
}

加载证书：

// 从文件加载
cert, err := tls.LoadX509KeyPair("server.crt", "server.key")

// 从内存加载
cert, err := tls.X509KeyPair(certPEM, keyPEM)

5. ClientAuthType - 客户端认证类型

type ClientAuthType int

const (
    NoClientCert ClientAuthType = iota // 不要求客户端证书
    RequestClientCert                  // 请求但不要求
    RequireAnyClientCert               // 要求任意证书
    VerifyClientCertIfGiven            // 验证提供的证书
    RequireAndVerifyClientCert         // 要求并验证（mTLS）
)

TLS 版本常量

const (
    VersionTLS10 = 0x0301
    VersionTLS11 = 0x0302
    VersionTLS12 = 0x0303
    VersionTLS13 = 0x0304
)

推荐配置：

&tls.Config{
    MinVersion: tls.VersionTLS12, // 最低 TLS 1.2
    MaxVersion: tls.VersionTLS13, // 支持 TLS 1.3
}

密码套件常量

安全的密码套件（推荐）

const (
    // TLS 1.2 密码套件
    TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256   uint16 = 0xc02f
    TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384   uint16 = 0xc030
    TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 uint16 = 0xc02b
    TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 uint16 = 0xc02c
    
    // TLS 1.3 密码套件（自动选择）
    TLS_AES_128_GCM_SHA256                  uint16 = 0x1301
    TLS_AES_256_GCM_SHA384                  uint16 = 0x1302
    TLS_CHACHA20_POLY1305_SHA256            uint16 = 0x1303
)

推荐配置：

CipherSuites: []uint16{
    tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
    tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
    tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
    tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
}

服务器端实现

示例 1：基础 TLS 服务器

package main

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

func main() {
    // 1. 创建 TLS 配置
    config := &tls.Config{
        MinVersion: tls.VersionTLS12,
        MaxVersion: tls.VersionTLS13,
    }
    
    // 2. 加载证书
    cert, err := tls.LoadX509KeyPair("server.crt", "server.key")
    if err != nil {
        log.Fatal(err)
    }
    config.Certificates = []tls.Certificate{cert}
    
    // 3. 创建 TLS 监听器
    listener, err := tls.Listen("tcp", ":8443", config)
    if err != nil {
        log.Fatal(err)
    }
    defer listener.Close()
    
    fmt.Println("TLS 服务器启动在 :8443")
    
    // 4. 启动 HTTP 服务器
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello, TLS!\n")
    })
    
    server := &http.Server{
        Handler: nil,
    }
    
    log.Fatal(server.Serve(listener))
}

示例 2：HTTPS 服务器（推荐方式）

package main

import (
    "fmt"
    "log"
    "net/http"
)

func main() {
    // 设置路由
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello, HTTPS!\n")
        fmt.Fprintf(w, "TLS 版本：%s\n", r.TLS.Version)
        fmt.Fprintf(w, "密码套件：%s\n", r.TLS.CipherSuite)
    })
    
    // 直接启动 HTTPS 服务器
    log.Println("HTTPS 服务器启动在 :8443")
    err := http.ListenAndServeTLS(":8443", "server.crt", "server.key", nil)
    if err != nil {
        log.Fatal(err)
    }
}

示例 3：双向 TLS（mTLS）服务器

package main

import (
    "crypto/tls"
    "crypto/x509"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
)

func main() {
    // 1. 加载服务器证书
    serverCert, err := tls.LoadX509KeyPair("server.crt", "server.key")
    if err != nil {
        log.Fatal(err)
    }
    
    // 2. 加载 CA 证书（用于验证客户端）
    caCert, err := ioutil.ReadFile("ca.crt")
    if err != nil {
        log.Fatal(err)
    }
    
    caCertPool := x509.NewCertPool()
    if !caCertPool.AppendCertsFromPEM(caCert) {
        log.Fatal("无法解析 CA 证书")
    }
    
    // 3. 创建 TLS 配置
    config := &tls.Config{
        Certificates: []tls.Certificate{serverCert},
        ClientCAs:    caCertPool,
        ClientAuth:   tls.RequireAndVerifyClientCert, // 要求并验证客户端证书
        MinVersion:   tls.VersionTLS12,
        MaxVersion:   tls.VersionTLS13,
    }
    
    // 4. 创建监听器
    listener, err := tls.Listen("tcp", ":8443", config)
    if err != nil {
        log.Fatal(err)
    }
    defer listener.Close()
    
    fmt.Println("mTLS 服务器启动在 :8443")
    
    // 5. 启动服务器
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        // 获取客户端证书信息
        if r.TLS != nil && len(r.TLS.PeerCertificates) > 0 {
            cert := r.TLS.PeerCertificates[0]
            fmt.Fprintf(w, "客户端证书主题：%s\n", cert.Subject.CommonName)
            fmt.Fprintf(w, "客户端证书颁发者：%s\n", cert.Issuer.CommonName)
        }
        fmt.Fprintf(w, "Hello, mTLS!\n")
    })
    
    server := &http.Server{
        Handler: nil,
    }
    
    log.Fatal(server.Serve(listener))
}

示例 4：动态证书选择（SNI）

package main

import (
    "crypto/tls"
    "fmt"
    "log"
    "sync"
)

// CertManager 证书管理器
type CertManager struct {
    certs map[string]*tls.Certificate
    mu    sync.RWMutex
}

// NewCertManager 创建证书管理器
func NewCertManager() *CertManager {
    return &CertManager{
        certs: make(map[string]*tls.Certificate),
    }
}

// AddCert 添加证书
func (m *CertManager) AddCert(domain string, certPath, keyPath string) error {
    cert, err := tls.LoadX509KeyPair(certPath, keyPath)
    if err != nil {
        return err
    }
    
    m.mu.Lock()
    m.certs[domain] = &cert
    m.mu.Unlock()
    
    return nil
}

// GetCertificate 获取证书（用于 GetCertificate 回调）
func (m *CertManager) GetCertificate(hello *tls.ClientHelloInfo) (*tls.Certificate, error) {
    m.mu.RLock()
    defer m.mu.RUnlock()
    
    // 首先尝试精确匹配
    if cert, ok := m.certs[hello.ServerName]; ok {
        return cert, nil
    }
    
    // 回退到默认证书
    for _, cert := range m.certs {
        return cert, nil
    }
    
    return nil, fmt.Errorf("未找到证书")
}

func main() {
    manager := NewCertManager()
    
    // 加载多个域名的证书
    manager.AddCert("example.com", "example.crt", "example.key")
    manager.AddCert("api.example.com", "api.crt", "api.key")
    
    // 创建 TLS 配置
    config := &tls.Config{
        MinVersion:     tls.VersionTLS12,
        GetCertificate: manager.GetCertificate,
    }
    
    // 监听
    listener, err := tls.Listen("tcp", ":443", config)
    if err != nil {
        log.Fatal(err)
    }
    defer listener.Close()
    
    fmt.Println("多域名 TLS 服务器启动")
    
    // 接受连接
    for {
        conn, err := listener.Accept()
        if err != nil {
            log.Printf("接受连接失败：%v", err)
            continue
        }
        go handleConnection(conn)
    }
}

func handleConnection(conn net.Conn) {
    defer conn.Close()
    // 处理连接...
}

客户端实现

示例 5：基础 TLS 客户端

package main

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

func main() {
    // 1. 创建 TLS 配置
    config := &tls.Config{
        MinVersion: tls.VersionTLS12,
        ServerName: "example.com", // 必须设置，用于验证证书
    }
    
    // 2. 建立 TLS 连接
    conn, err := tls.Dial("tcp", "example.com:443", config)
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()
    
    // 3. 检查连接状态
    state := conn.ConnectionState()
    fmt.Printf("TLS 版本：%x\n", state.Version)
    fmt.Printf("密码套件：%x\n", state.CipherSuite)
    fmt.Printf("服务器证书：%s\n", state.PeerCertificates[0].Subject.CommonName)
    
    // 4. 发送请求
    request := "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"
    _, err = conn.Write([]byte(request))
    if err != nil {
        log.Fatal(err)
    }
    
    // 5. 读取响应
    response, err := ioutil.ReadAll(conn)
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("响应：%s\n", response)
}

示例 6：HTTPS 客户端

package main

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

func main() {
    // 1. 创建 TLS 配置
    tlsConfig := &tls.Config{
        MinVersion: tls.VersionTLS12,
    }
    
    // 2. 创建 HTTP 传输
    transport := &http.Transport{
        TLSClientConfig: tlsConfig,
    }
    
    // 3. 创建 HTTP 客户端
    client := &http.Client{
        Transport: transport,
    }
    
    // 4. 发送请求
    resp, err := client.Get("https://example.com")
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()
    
    // 5. 读取响应
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("状态码：%d\n", resp.StatusCode)
    fmt.Printf("响应长度：%d 字节\n", len(body))
}

示例 7：使用客户端证书（mTLS 客户端）

package main

import (
    "crypto/tls"
    "crypto/x509"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
)

func main() {
    // 1. 加载客户端证书
    clientCert, err := tls.LoadX509KeyPair("client.crt", "client.key")
    if err != nil {
        log.Fatal(err)
    }
    
    // 2. 加载 CA 证书（验证服务器）
    caCert, err := ioutil.ReadFile("ca.crt")
    if err != nil {
        log.Fatal(err)
    }
    
    caCertPool := x509.NewCertPool()
    if !caCertPool.AppendCertsFromPEM(caCert) {
        log.Fatal("无法解析 CA 证书")
    }
    
    // 3. 创建 TLS 配置
    tlsConfig := &tls.Config{
        MinVersion:   tls.VersionTLS12,
        Certificates: []tls.Certificate{clientCert},
        RootCAs:      caCertPool,
        ServerName:   "example.com",
    }
    
    // 4. 创建 HTTP 传输
    transport := &http.Transport{
        TLSClientConfig: tlsConfig,
    }
    
    // 5. 创建 HTTP 客户端
    client := &http.Client{
        Transport: transport,
    }
    
    // 6. 发送请求
    resp, err := client.Get("https://example.com")
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()
    
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("状态码：%d\n", resp.StatusCode)
    fmt.Printf("响应：%s\n", body)
}

示例 8：跳过证书验证（仅用于测试）

package main

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

func main() {
    // ⚠️ 警告：仅用于测试环境！
    
    // 1. 创建 TLS 配置（跳过验证）
    tlsConfig := &tls.Config{
        InsecureSkipVerify: true, // ⚠️ 不安全！
        MinVersion:         tls.VersionTLS12,
    }
    
    // 2. 创建 HTTP 传输
    transport := &http.Transport{
        TLSClientConfig: tlsConfig,
    }
    
    // 3. 创建 HTTP 客户端
    client := &http.Client{
        Transport: transport,
    }
    
    // 4. 发送请求
    resp, err := client.Get("https://self-signed.example.com")
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()
    
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("状态码：%d\n", resp.StatusCode)
}

证书管理

示例 9：自签名证书生成

package main

import (
    "crypto/ecdsa"
    "crypto/elliptic"
    "crypto/rand"
    "crypto/x509"
    "crypto/x509/pkix"
    "encoding/pem"
    "log"
    "math/big"
    "os"
    "time"
)

func main() {
    // 1. 生成私钥
    priv, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
    if err != nil {
        log.Fatal(err)
    }
    
    // 2. 创建证书模板
    template := x509.Certificate{
        SerialNumber: big.NewInt(1),
        Subject: pkix.Name{
            Organization: []string{"My Org"},
            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,
        DNSNames:              []string{"localhost", "example.com"},
        IPAddresses:           []net.IP{net.ParseIP("127.0.0.1")},
    }
    
    // 3. 创建证书
    derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, &priv.PublicKey, priv)
    if err != nil {
        log.Fatal(err)
    }
    
    // 4. 保存证书
    certFile, err := os.Create("server.crt")
    if err != nil {
        log.Fatal(err)
    }
    defer certFile.Close()
    
    pem.Encode(certFile, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes})
    
    // 5. 保存私钥
    keyFile, err := os.Create("server.key")
    if err != nil {
        log.Fatal(err)
    }
    defer keyFile.Close()
    
    privBytes, err := x509.MarshalECPrivateKey(priv)
    if err != nil {
        log.Fatal(err)
    }
    
    pem.Encode(keyFile, &pem.Block{Type: "EC PRIVATE KEY", Bytes: privBytes})
    
    log.Println("证书生成成功")
}

示例 10：证书验证回调

package main

import (
    "crypto/tls"
    "crypto/x509"
    "fmt"
    "log"
)

func main() {
    // 创建 TLS 配置
    config := &tls.Config{
        MinVersion: tls.VersionTLS12,
        ServerName: "example.com",
        
        // 自定义证书验证
        VerifyPeerCertificate: func(rawCerts [][]byte, verifiedChains [][]*x509.Certificate) error {
            // 1. 解析证书
            cert, err := x509.ParseCertificate(rawCerts[0])
            if err != nil {
                return err
            }
            
            // 2. 自定义验证逻辑
            fmt.Printf("证书主题：%s\n", cert.Subject.CommonName)
            fmt.Printf("证书颁发者：%s\n", cert.Issuer.CommonName)
            fmt.Printf("证书有效期：%s - %s\n", cert.NotBefore, cert.NotAfter)
            
            // 3. 可以添加额外的验证逻辑
            // 例如：检查证书指纹、检查特定扩展等
            
            return nil // 返回 nil 表示验证通过
        },
    }
    
    // 建立连接
    conn, err := tls.Dial("tcp", "example.com:443", config)
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()
    
    fmt.Println("连接成功")
}

安全最佳实践

✅ 推荐做法

1. 始终使用 TLS 1.2 或更高版本

   config := &tls.Config{
       MinVersion: tls.VersionTLS12,
       MaxVersion: tls.VersionTLS13,
   }
   

2. 配置安全的密码套件

   CipherSuites: []uint16{
       tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
       tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
       tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
       tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
   }
   

3. 始终验证服务器证书

   // ✅ 正确
   config := &tls.Config{
       ServerName: "example.com",
   }
   
   // ❌ 错误（仅用于测试）
   config := &tls.Config{
       InsecureSkipVerify: true,
   }
   

4. 使用强密钥

   // ✅ RSA 2048+ 或 ECDSA P-256+
   priv, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
   

5. 实现证书轮换

   config := &tls.Config{
       GetCertificate: func(hello *tls.ClientHelloInfo) (*tls.Certificate, error) {
           // 动态加载新证书
           return loadLatestCertificate()
       },
   }
   

6. 使用 mTLS 进行服务间认证

   config := &tls.Config{
       ClientAuth: tls.RequireAndVerifyClientCert,
       ClientCAs:  caCertPool,
   }
   

❌ 不安全做法

1. 不要使用 TLS 1.0/1.1

   // ❌ 绝对不要
   config := &tls.Config{
       MinVersion: tls.VersionTLS10, // 不安全！
   }
   

2. 不要在生产环境跳过验证

   // ❌ 绝对不要
   config := &tls.Config{
       InsecureSkipVerify: true, // 仅用于测试！
   }
   

3. 不要使用弱密码套件

   // ❌ 避免
   CipherSuites: []uint16{
       tls.TLS_RSA_WITH_AES_128_CBC_SHA, // 弱，无前向保密
   }
   

4. 不要使用过期证书

   // 始终检查证书有效期
   if cert.NotAfter.Before(time.Now()) {
       log.Fatal("证书已过期")
   }
   

常见错误处理

1. 证书验证错误

conn, err := tls.Dial("tcp", "example.com:443", config)
if err != nil {
    if err, ok := err.(x509.UnknownAuthorityError); ok {
        log.Printf("未知证书颁发机构：%v", err)
    } else if err, ok := err.(x509.CertificateInvalidError); ok {
        log.Printf("证书无效：%v", err)
    } else {
        log.Printf("TLS 错误：%v", err)
    }
}

2. 握手错误

conn, err := tls.Dial("tcp", "example.com:443", config)
if err != nil {
    if strings.Contains(err.Error(), "handshake failure") {
        log.Printf("握手失败：可能是不支持的协议版本或密码套件")
    }
}

3. 证书过期检测

func checkCertificateExpiry(certPath string) error {
    certPEM, err := ioutil.ReadFile(certPath)
    if err != nil {
        return err
    }
    
    block, _ := pem.Decode(certPEM)
    if block == nil {
        return fmt.Errorf("无法解析证书")
    }
    
    cert, err := x509.ParseCertificate(block.Bytes)
    if err != nil {
        return err
    }
    
    // 检查有效期
    now := time.Now()
    if now.Before(cert.NotBefore) {
        return fmt.Errorf("证书尚未生效")
    }
    if now.After(cert.NotAfter) {
        return fmt.Errorf("证书已过期：%s", cert.NotAfter)
    }
    
    // 提前 30 天警告
    if cert.NotAfter.Sub(now) < 30*24*time.Hour {
        log.Printf("警告：证书将在 30 天内过期")
    }
    
    return nil
}

总结

核心 API

// 服务器端
listener, err := tls.Listen("tcp", ":8443", config)
conn, err := listener.Accept()

// 客户端
conn, err := tls.Dial("tcp", "example.com:443", config)
client := &http.Client{
    Transport: &http.Transport{
        TLSClientConfig: config,
    },
}

// 证书加载
cert, err := tls.LoadX509KeyPair("server.crt", "server.key")

// HTTPS 服务器
err := http.ListenAndServeTLS(":8443", "server.crt", "server.key", handler)

安全配置清单

• 使用 TLS 1.2 或 1.3
• 配置安全的密码套件
• 始终验证服务器证书
• 使用强密钥（RSA 2048+ 或 ECDSA P-256+）
• 实现证书监控和轮换
• 考虑使用 mTLS
• 不在生产环境使用 InsecureSkipVerify
• 定期检查证书有效期

使用场景

TLS 版本对比

参考资料

• Go crypto/tls 包文档
• RFC 8446 - TLS 1.3
• RFC 5246 - TLS 1.2
• Mozilla SSL 配置生成器
• OWASP TLS 最佳实践

最后更新：2026-04-03
Go 版本：Go 1.23+
安全状态：✅ 推荐使用（正确配置下）