Go语言中实现STARTTLS：TCP连接到TLS的平滑升级

import (
    "crypto/tls"
    "log"
)

// PrepareTLSConfig 准备TLS配置
func PrepareTLSConfig(certPath, keyPath, serverName string) (*tls.Config, error) {
    // 加载服务器证书和私钥
    cert, err := tls.LoadX509KeyPair(certPath, keyPath)
    if err != nil {
        log.Printf("加载X.509密钥对失败: %v", err)
        return nil, err
    }

    // 创建TLS配置
    tlsConfig := &tls.Config{
        Certificates: []tls.Certificate{cert},
        // ClientAuth 定义了服务器对客户端证书的验证策略。
        // tls.NoClientCert: 不要求或验证客户端证书。
        // tls.RequestClientCert: 如果客户端提供，则请求但不需要验证。
        // tls.VerifyClientCertIfGiven: 如果客户端提供，则验证。
        // tls.RequireAndVerifyClientCert: 必须提供并验证客户端证书。
        ClientAuth: tls.NoClientCert, // 根据需求设置客户端认证策略
        ServerName: serverName,       // 用于SNI (Server Name Indication) 验证
        MinVersion: tls.VersionTLS12, // 建议设置最小TLS版本以增强安全性
    }
    return tlsConfig, nil
}

import (
    "bufio"
    "crypto/tls"
    "io"
    "log"
    "net"
    "net/textproto"
    "time"
)

// UpgradeConnectionToTLS 示例函数，演示如何升级连接
func UpgradeConnectionToTLS(conn net.Conn, tlsConfig *tls.Config) (net.Conn, error) {
    // 1. 使用 tls.Server 包装现有的 net.Conn
    // tls.Server 函数会返回一个 *tls.Conn 类型，它实现了 net.Conn 接口。
    // 重要的是要保留这个 *tls.Conn 类型的引用，以便后续调用 Handshake()。
    tlsConn := tls.Server(conn, tlsConfig)

    // 2. 执行TLS握手
    // 握手是协商加密参数、交换证书和验证身份的关键步骤。
    // 在握手完成之前，任何通过 tlsConn 的读写操作都将失败或导致未定义行为。
    // 建议设置握手超时，防止客户端长时间不响应。
    tlsConn.SetReadDeadline(time.Now().Add(10 * time.Second)) // 设置一个短的握手超时
    err := tlsConn.Handshake()
    if err != nil {
        log.Printf("TLS握手失败: %v", err)
        // 握手失败后，应该关闭连接
        tlsConn.Close()
        return nil, err
    }
    tlsConn.SetReadDeadline(time.Time{}) // 握手成功后清除超时

    log.Println("TLS握手成功，连接已升级为TLS加密。")

    // 3. 返回升级后的连接
    // 此时，tlsConn 已经是一个完全加密的连接，可以像使用普通 net.Conn 一样进行读写。
    // 如果你的上层协议处理（如 textproto.Conn）需要一个新的 net.Conn 实例，
    // 可以直接使用 tlsConn，因为它实现了 net.Conn 接口。
    return tlsConn, nil
}

// 示例：服务器处理逻辑骨架
func handleClient(conn net.Conn, tlsConfig *tls.Config) {
    defer conn.Close()

    // 初始的 textproto.Conn 用于非TLS阶段的读写
    reader := bufio.NewReader(conn)
    writer := bufio.NewWriter(conn)
    tpConn := textproto.NewConn(reader, writer)

    // 模拟SMTP服务器的初始问候
    tpConn.PrintfLine("220 example.com ESMTP Service ready")

    for {
        line, err := tpConn.ReadLine()
        if err != nil {
            if err != io.EOF {
                log.Printf("读取连接数据失败: %v", err)
            }
            break
        }
        log.Printf("收到命令: %s", line)

        switch {
        case line == "STARTTLS":
            tpConn.PrintfLine("220 Start TLS")
            // 刷新缓冲区，确保 "220 Start TLS" 响应已发送给客户端
            if err := tpConn.Writer.Flush(); err != nil {
                log.Printf("刷新缓冲区失败: %v", err)
                return
            }

            // 执行TLS升级
            newConn, err := UpgradeConnectionToTLS(conn, tlsConfig)
            if err != nil {
                log.Printf("升级TLS连接失败: %v", err)
                return
            }
            // 升级成功后，必须更新当前连接变量和所有依赖于它的I/O读写器
            conn = newConn
            reader = bufio.NewReader(conn)
            writer = bufio.NewWriter(conn)
            tpConn = textproto.NewConn(reader, writer) // 重新创建 textproto.Conn

            log.Println("连接已成功升级，继续处理TLS加密请求。")
            // 升级后，通常客户端会重新发送EHLO/HELO命令
        case line == "EHLO example.com" || line == "HELO example.com":
            tpConn.PrintfLine("250-example.com Hello %s", "client.example.com")
            if conn, ok := conn.(*tls.Conn); ok {
                // 如果是TLS连接，可以告知客户端支持的扩展
                tpConn.PrintfLine("250-PIPELINING")
                tpConn.PrintfLine("250-8BITMIME")
                tpConn.PrintfLine("250-SIZE")
                tpConn.PrintfLine("250-AUTH PLAIN LOGIN")
                tpConn.PrintfLine("250-STARTTLS") // 如果已经升级，这里可以不列出
                tpConn.PrintfLine("250 DSN")
            } else {
                tpConn.PrintfLine("250-STARTTLS") // 非TLS连接时告知支持STARTTLS
                tpConn.PrintfLine("250 DSN")
            }
        case line == "QUIT":
            tpConn.PrintfLine("221 Bye")
            return
        default:
            tpConn.PrintfLine("502 Command not implemented")
        }

        if err := tpConn.Writer.Flush(); err != nil {
            log.Printf("发送响应失败: %v", err)
            return
        }
    }
}

// main函数示例
func main() {
    certPath := "server.crt" // 替换为你的证书路径
    keyPath := "server.key"  // 替换为你的私钥路径
    serverName := "example.com"

    tlsConfig, err := PrepareTLSConfig(certPath, keyPath, serverName)
    if err != nil {
        log.Fatalf("准备TLS配置失败: %v", err)
    }

    listener, err := net.Listen("tcp", ":25") // 监听SMTP标准端口
    if err != nil {
        log.Fatalf("监听端口失败: %v", err)
    }
    defer listener.Close()
    log.Printf("SMTP服务器在 :25 端口监听...")

    for {
        conn, err := listener.Accept()
        if err != nil {
            log.Printf("接受连接失败: %v", err)
            continue
        }
        log.Printf("接受来自 %s 的新连接", conn.RemoteAddr())
        go handleClient(conn, tlsConfig)
    }
}

openssl s_client -starttls smtp -crlf -connect example.com:25