Go语言中基于自签名证书和公钥校验的安全双向认证连接实现

陆砚码

2026-09-07 • 👁 1人浏览过

本教程详细阐述了如何在Go语言中，利用自签名X.509证书和 crypto /tls库，为完全受控的客户端与服务器端建立安全的双向认证连接。文章涵盖了使用OpenSSL生成证书与密钥、配置TLS连接参数、以及通过比对预设公钥实现对等方身份验证的关键步骤，旨在提供一种在非信任网络环境下实现高安全性通信的专业指导。核心概念：受控环境下的自签名证书与双向认证在构建客户端与服务器之间通过非信任网络进行通信的系统时，确保连接的安全性至关重要。当开发者对通信的两端（客户端和服务器）都拥有完全控制权时，使用自签名X.509证书结合Go语言的crypto/tls库是一种高效且灵活的解决方案。这种方法避免了依赖第三方证书颁发机构（CA），简化了证书管理流程，同时能实现强大的双向身份认证。双向认证（Mutual TLS, mTLS）意味着通信的双方都会验证对方的身份。服务器会验证客户端的证书，客户端也会验证服务器的证书。在本场景中，由于我们不依赖CA，传统的证书链验证机制不再适用。取而代之的是，我们将通过预先安全分发并比对对等方的公钥来完成身份验证，这被称为“公钥锁定”（Public Key Pinning）的一种简化形式。对于Go语言中crypto/x509.CreateCertificate()函数所需的众多参数（如SerialNumber, Subject, NotBefore, NotAfter等），虽然它们在创建证书时是必需的，但通过使用OpenSSL工具来生成自签名证书，可以有效规避直接在Go代码中处理这些复杂参数的困扰。OpenSSL将负责生成符合X.509标准的证书文件，Go程序只需加载这些文件即可。生成自签名X.509密钥对为了实现双向认证，客户端和服务器端都需要拥有各自独立的私钥和对应的自签名证书。以下步骤演示如何使用OpenSSL为每个端点生成所需的密钥对。请为服务器和客户端分别执行这些命令，例如，为服务器生成server.key和server.crt，为客户端生成client.key和client.crt。立即学习 “ go语言免费学习笔记（深入） ”；生成RSA私钥（带密码保护）首先，为您的端点生成一个RSA私钥。-des3参数会为私钥设置一个密码，提高安全性。

openssl genrsa -des3 -out server.key 1024
# 提示输入密码，请记住此密码。

（注意：生产环境中建议使用更长的密钥，如2048或4096位）创建证书签名请求（CSR）使用上一步生成的私钥创建一个证书签名请求。在这一步中，您需要填写一些关于证书所有者的信息（例如国家、组织、通用名称等）。

openssl req -new -key server.key -out server.csr
# 提示输入私钥密码，然后填写证书信息。
# Common Name (e.g. server FQDN or YOUR name) []: 填写服务器或客户端的主机名/IP地址

移除私钥密码（可选但推荐，方便Go程序加载）为了方便Go程序在运行时加载私钥而无需交互式输入密码，通常会移除私钥的密码保护。请务必妥善保护无密码的私钥文件。

cp server.key server.key.org # 备份原始带密码的私钥
openssl rsa -in server.key.org -out server.key
# 提示输入原始私钥密码

自签名证书最后，使用私钥对CSR进行自签名，生成最终的X.509证书文件。-days 365参数设置了证书的有效期为365天。在完全受控的环境中，即使证书过期，您也可以随时重新生成，因此这个值并非严格限制。

openssl x509 -req -days 365 -in server.csr -signkey server.key -out server.crt

完成上述步骤后，您将拥有 server.key (无密码私钥) 和 server.crt (自签名证书)。请为客户端重复这些步骤，生成 client.key 和 client.crt。 go语言参考手册中文CHM版 Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。本文给大家带来Go参考手册，需要的可以来下载！ Go是从2007年末由Robert Griesemer, Rob Pike, Ken Thompson主持开发，后来还加入了Ian Lance Taylor, Russ Cox等人，并最终于2009年11月开源，在2012年早些时候发布了Go 1稳定版本。现在Go的开发已经是完全开放的，并且拥有一个活跃的社区。 Go 语言特色简洁、快速、安全并行、有趣、开源内存管理、v数组安全、编译下载 Go语言中TLS安全连接的实现在拥有了客户端和服务器各自的证书和私钥文件后，我们可以使用Go语言的crypto/tls库来建立安全的双向认证连接。 1. 加载证书与私钥 Go程序首先需要加载自身的证书和私钥。

package main

import (
    "crypto/tls"
    "crypto/x509"
    "io/ioutil"
    "log"
    "net"
    "bytes" // 用于公钥比对
)

// loadCertificateAndKey loads the certificate and key files.
func loadCertificateAndKey(certFile, keyFile string) (tls.Certificate, error) {
    cert, err := tls.LoadX509KeyPair(certFile, keyFile)
    if err != nil {
        return tls.Certificate{}, err
    }
    return cert, nil
}

2. 构建TLS配置 tls.Config结构体用于配置TLS连接的各种参数。客户端和服务器端都需要一个tls.Config实例，但某些选项的设置会有所不同。

// createTLSConfig creates a tls.Config suitable for both client and server,
// with specific adjustments for client/server roles.
func createTLSConfig(myCert tls.Certificate, isServer bool, knownPeerPublicKey []byte) *tls.Config {
    config := &tls.Config{
        Certificates: []tls.Certificate{myCert}, // 加载自身的证书
        // 对于自签名证书，我们不进行传统的CA链验证，而是依赖后续的公钥比对。
        // 因此，在客户端侧，通常会设置 InsecureSkipVerify 为 true。
        // 但请注意，这仅表示跳过证书链验证，不代表完全不验证对端身份。
        // 真正的身份验证将在连接建立后通过比对公钥完成。
        InsecureSkipVerify: true, // 客户端通常需要设置为 true，因为没有CA来验证服务器证书
    }

    if isServer {
        // 服务器端需要验证客户端证书，以实现双向认证
        config.ClientAuth = tls.RequireAnyClientCert // 要求客户端提供证书
    }

    // 如果有需要，可以在这里添加其他配置，例如CipherSuites等
    return config
}

关于InsecureSkipVerify: true的注意事项：这个参数设置为true时，crypto/tls库将跳过对对等方证书链的验证，这意味着它不会检查证书是否由受信任的CA颁发、是否过期或被吊销。在我们的自签名证书和公钥校验场景中，这是必要的，因为我们没有CA。然而，这并不意味着连接是安全的。真正的安全性来自于后续对对等方公钥的显式校验。如果仅设置InsecureSkipVerify: true而不进行额外的公钥校验，那么连接将容易受到中间人攻击。 3. 服务器端：建立TLS监听服务器端使用tls.Listen来创建一个TLS监听器，等待客户端连接。

// startServer starts a TLS server on the given address.
func startServer(addr string, myCert tls.Certificate, knownClientPublicKey []byte) {
    config := createTLSConfig(myCert, true, knownClientPublicKey) // isServer = true
    listener, err := tls.Listen("tcp", addr, config)
    if err != nil {
        log.Fatalf("Server: Failed to start TLS listener: %v", err)
    }
    defer listener.Close()
    log.Printf("Server: Listening on %s", addr)

    for {
        conn, err := listener.Accept()
        if err != nil {
            log.Printf("Server: Failed to accept connection: %v", err)
            continue
        }
        go handleConnection(conn, knownClientPublicKey, true)
    }
}

4. 客户端：发起TLS连接客户端使用tls.Dial来与服务器建立TLS连接。

// startClient connects to a TLS server.
func startClient(addr string, myCert tls.Certificate, knownServerPublicKey []byte) {
    config := createTLSConfig(myCert, false, knownServerPublicKey) // isServer = false
    conn, err := tls.Dial("tcp", addr, config)
    if err != nil {
        log.Fatalf("Client: Failed to dial TLS server: %v", err)
    }
    defer conn.Close()
    log.Printf("Client: Connected to %s", addr)

    handleConnection(conn, knownServerPublicKey, false)
}

实现对等方身份验证：公钥校验这是确保连接安全性的核心步骤。在TLS握手完成后，我们可以从连接状态中提取对等方的证书，并将其中的公钥与我们预先知道的、受信任的公钥进行比对。


// handleConnection processes a TLS connection, including peer public key verification.
func handleConnection(conn net.Conn, knownPeerPublicKey []byte, isServer bool) {
    defer conn.Close()

    tlsConn, ok := conn.(*tls.Conn)
    if !ok {
        log.Printf("Error: Connection is not a TLS connection.")
        return
    }

    // 确保TLS握手已完成
    err := tlsConn.Handshake()
    if err != nil {
        log.Printf("Error during TLS handshake: %v", err)
        return
    }

    // 获取连接状态
    state := tlsConn.ConnectionState()

    // 检查对等方是否提供了证书
    if len(state.PeerCertificates) == 0 {
        log.Printf("Error: Peer did not provide a certificate for authentication.")
        return
    }

    // 提取对等方的第一个证书（通常只有一个）
    peerCert := state.PeerCertificates[0]

    // 从证书中提取公钥
    peerPublicKeyBytes, err := x509.MarshalPKIXPublicKey(peerCert.PublicKey)
    if err != nil {
        log.Printf("Error marshalling peer public key: %v", err)
        return
    }

    // 比对提取到的公钥与预设的已知公钥
    if !bytes.Equal(peerPublicKeyBytes, knownPeerPublicKey) {
        log.Printf("Authentication failed: Peer public key mismatch.")
        log.Printf("Expected public key: %x", knownPeerPublicKey)
        log.Printf("Received public key: %x", peerPublicKeyBytes)
        return
    }

    log.Printf("Authentication successful: Peer public key matches.")
    // 至此，连接已加密且对等方身份已验证。可以进行安全通信。

    // 示例：发送和接收数据
    if isServer {
        _, err := conn.Write([]byte("Hello from server!\n"))
        if err != nil {
            log.Printf("Server: Write error: %v", err)
        }
        buf := make([]byte, 1024)
        n, err := conn.Read(buf)
        if err != nil {
            log.Printf("Server: Read error: %v", err)
            return
        }
        log.Printf("Server: Received: %s", string(buf[:n]))
    } else { // Client
        buf := make([]byte, 1024)
        n, err := conn.Read(buf)
        if err != nil {
            log.Printf("Client: Read error: %v", err)
            return
        }
        log.Printf("Client: Received: %s", string(buf[:n]))
        _, err = conn.Write([]byte("Hello from client!\n"))
        if err != nil {
            log.Printf("Client: Write error: %v", err)
        }
    }
}

// Helper function to extract public key from a .crt file
func getPublicKeyFromCertFile(certFile string) ([]byte, error) {
    certPEMBlock, err := ioutil.ReadFile(certFile)
    if err != nil {
        return nil, err
    }
    cert, err := x509.ParseCertificate(certPEMBlock)
    if err != nil {
        // Try parsing as PEM block if direct parse fails (e.g. if it's a bundle)
        block, _ := pem.Decode(certPEMBlock)
        if block == nil || block.Type != "CERTIFICATE" {
            return nil, fmt.Errorf("failed to decode PEM block containing certificate")

相关文章