如何在Golang TLS TCP握手时获取clientCert.Subject.CommonName？

问题分析 #

你的核心需求是让不同CN的客户端连接时，服务器使用对应的专属证书，但当前代码遇到两个问题：

1. *tls.Conn类型转换失败或PeerCertificates为空
2. 无法在发送服务器证书前获取客户端证书的CN（受TLS握手流程限制）

解决类型转换与PeerCertificates为空问题 #

tls.Listen返回的监听器，Accept()方法返回的conn本质就是*tls.Conn，类型转换失败大概率是代码逻辑错误（比如监听器不是tls.Listen创建）。而PeerCertificates为空是因为握手未完成，必须先主动触发握手：

certPool := x509.NewCertPool()
clientCACert, err := ioutil.ReadFile("client-ca.crt")
if err != nil {
    log.Fatal(err)
}
certPool.AppendCertsFromPEM(clientCACert)

// 基础TLS配置（临时证书用于初始握手）
tempCert, err := tls.LoadX509KeyPair("temp-server.crt", "temp-server.key")
if err != nil {
    log.Fatal(err)
}
baseTLSConfig := &tls.Config{
    Certificates: []tls.Certificate{tempCert},
    ClientCAs:    certPool,
    ClientAuth:   tls.RequireAndVerifyClientCert,
}

listener, err := tls.Listen("tcp", ":8080", baseTLSConfig)
if err != nil {
    log.Fatal(err)
}

for {
    conn, err := listener.Accept()
    if err != nil {
        log.Println("accept failed:", err)
        continue
    }
    go func(conn net.Conn) {
        defer conn.Close()
        tlsConn, ok := conn.(*tls.Conn)
        if !ok {
            log.Println("invalid TLS connection")
            return
        }
        // 主动完成TLS握手
        if err := tlsConn.Handshake(); err != nil {
            log.Println("handshake failed:", err)
            return
        }
        state := tlsConn.ConnectionState()
        if len(state.PeerCertificates) == 0 {
            log.Println("no client certificate provided")
            return
        }
        clientCN := state.PeerCertificates[0].Subject.CommonName
        log.Println("connected client CN:", clientCN)
        // 后续业务逻辑
    }(conn)
}

核心需求解决方案：动态选择服务器证书 #

由于TLS标准握手流程中，服务器证书会在客户端证书之前发送，无法先获取客户端CN再发送对应服务器证书，因此提供两种可行方案：

方案一：TLS重新协商 #

先用临时服务器证书完成初始握手，验证客户端证书并获取CN后，发起TLS重新协商，切换为对应服务器证书：

// 预加载所有服务器证书，建立CN到证书的映射
serverCertMap := make(map[string]*tls.Certificate)

// 加载客户端1对应的服务器证书
certClient1, err := tls.LoadX509KeyPair("server-client1.crt", "server-client1.key")
if err != nil {
    log.Fatal(err)
}
serverCertMap["client1"] = &certClient1

// 加载客户端2对应的服务器证书
certClient2, err := tls.LoadX509KeyPair("server-client2.crt", "server-client2.key")
if err != nil {
    log.Fatal(err)
}
serverCertMap["client2"] = &certClient2

// 初始握手用的临时证书
tempCert, err := tls.LoadX509KeyPair("temp-server.crt", "temp-server.key")
if err != nil {
    log.Fatal(err)
}

// 基础TLS配置
baseTLSConfig := &tls.Config{
    Certificates: []tls.Certificate{tempCert},
    ClientCAs:    certPool,
    ClientAuth:   tls.RequireAndVerifyClientCert,
}

listener, err := tls.Listen("tcp", ":8080", baseTLSConfig)
if err != nil {
    log.Fatal(err)
}

for {
    conn, err := listener.Accept()
    if err != nil {
        log.Println("accept failed:", err)
        continue
    }
    go handleClientConn(conn, serverCertMap, certPool)
}

func handleClientConn(conn net.Conn, certMap map[string]*tls.Certificate, clientCA *x509.CertPool) {
    defer conn.Close()
    tlsConn := conn.(*tls.Conn)

    // 完成初始握手，验证客户端证书
    if err := tlsConn.Handshake(); err != nil {
        log.Println("initial handshake failed:", err)
        return
    }

    state := tlsConn.ConnectionState()
    if len(state.PeerCertificates) == 0 {
        log.Println("no client certificate")
        return
    }
    clientCN := state.PeerCertificates[0].Subject.CommonName

    // 获取对应服务器证书
    targetCert, ok := certMap[clientCN]
    if !ok {
        log.Println("no matching server cert for client CN:", clientCN)
        return
    }

    // 构造新的TLS配置，发起重新协商
    newConfig := &tls.Config{
        Certificates: []tls.Certificate{*targetCert},
        ClientCAs:    clientCA,
        ClientAuth:   tls.RequireAndVerifyClientCert,
    }

    if err := tlsConn.HandshakeContext(context.Background(), newConfig); err != nil {
        log.Println("renegotiation failed:", err)
        return
    }

    // 此时连接已使用对应服务器证书，处理业务逻辑
    log.Println("switched to server cert for client:", clientCN)
    // 示例：读取客户端数据
    buf := make([]byte, 1024)
    n, err := tlsConn.Read(buf)
    if err != nil {
        log.Println("read failed:", err)
        return
    }
    log.Println("received data:", string(buf[:n]))
}

方案二：利用SNI扩展（需客户端配合） #

如果客户端可以将自己证书的CN作为SNI（Server Name Indication）发送，那么可以在GetConfigForClient回调中直接根据SNI选择服务器证书，后续再验证客户端证书CN与SNI是否一致：

// 预加载服务器证书映射
serverCertMap := make(map[string]*tls.Certificate)
// 加载证书逻辑同方案一...

baseTLSConfig := &tls.Config{
    ClientCAs:    certPool,
    ClientAuth:   tls.RequireAndVerifyClientCert,
    MinVersion:   tls.VersionTLS12, // SNI需TLS1.2及以上支持
    GetConfigForClient: func(hello *tls.ClientHelloInfo) (*tls.Config, error) {
        // 从SNI获取客户端CN（需客户端配置SNI为自身证书CN）
        clientCN := hello.ServerName
        targetCert, ok := serverCertMap[clientCN]
        if !ok {
            return nil, fmt.Errorf("no server certificate for %s", clientCN)
        }
        return &tls.Config{
            Certificates: []tls.Certificate{*targetCert},
            ClientCAs:    certPool,
            ClientAuth:   tls.RequireAndVerifyClientCert,
        }, nil
    },
}

listener, err := tls.Listen("tcp", ":8080", baseTLSConfig)
if err != nil {
    log.Fatal(err)
}

for {
    conn, err := listener.Accept()
    if err != nil {
        log.Println("accept failed:", err)
        continue
    }
    go func(conn net.Conn) {
        defer conn.Close()
        tlsConn := conn.(*tls.Conn)
        if err := tlsConn.Handshake(); err != nil {
            log.Println("handshake failed:", err)
            return
        }
        state := tlsConn.ConnectionState()
        if len(state.PeerCertificates) == 0 {
            log.Println("no client certificate")
            return
        }
        // 验证客户端证书CN与SNI一致，防止伪造
        clientCN := state.PeerCertificates[0].Subject.CommonName
        sniCN := state.ServerName
        if clientCN != sniCN {
            log.Println("client CN mismatch with SNI:", clientCN, "vs", sniCN)
            return
        }
        // 处理业务逻辑
        log.Println("valid connection from client:", clientCN)
    }(conn)
}

内容的提问来源于stack exchange，提问作者Andrew Arrow