使用 Go 框架为 Angular SPA 实现动态短生命周期 mTLS 认证

后端架构

文章字数: 4.3k

阅读时长: 18 分

项目要求在一个零信任（Zero Trust）网络环境中部署我们的 Angular 单页应用（SPA）。传统的认证方案，比如单纯依赖 JWT，在这里遇到了一个核心挑战：JWT 验证了用户是谁，但它无法验证发出请求的设备或工作负载的合法性。在一个内部网络也不可信的环境中，任何能窃取到有效 JWT 的恶意程序，都可以冒充用户向后端服务发起请求。我们需要一种机制，将用户的认证会话强绑定到其发起请求的设备实例上。

第一反应是双向 TLS（mTLS）。让每个合法客户端都持有一个独一无二的客户端证书，服务器在处理请求前，不仅要提供自己的证书，还必须验证客户端提供的证书是否由我们信任的 CA 签发。这能有效地将认证从应用层下沉到传输层，为设备本身提供了一个强身份标识。

但这立刻引出了下一个，也是更棘手的问题：如何为成千上万个部署在用户浏览器环境中的 SPA 客户端，安全、动态地分发和管理这些证书？静态地为每个用户预置证书，并要求他们手动安装，这在运维上是一场灾难，用户体验也极差。证书的轮换、吊销更是难上加难。

我们最终的技术决策是，放弃静态证书管理，转而构建一个轻量级的、与用户认证流程集成的动态证书签发服务。后端使用 Go，因其标准库 crypto/tls 和 crypto/x509 提供了构建 PKI 所需的全部原子能力，且其高性能的网络模型非常适合作为 API 网关。前端 Angular SPA 本身不直接参与 TLS 握手，因为浏览器环境的 API 对此有严格限制且能力不足。我们设计了一种在企业环境中更为现实的“伴侣代理”（Companion Proxy）模式：Angular 应用的所有 API 请求都发送到本机运行的一个轻量级代理，由这个代理负责处理复杂的 mTLS 握手和证书生命周期管理。

这个方案的核心是将身份认证分为两步：

用户认证: 用户通过传统方式（如用户名密码）登录，获取一个短生命周期的 Bootstrap JWT。
设备/会话认证: 客户端使用这个 JWT，向一个专门的证书签发服务请求一个生命周期更短（例如1小时）的客户端证书。后续所有业务 API 的调用，都必须通过 mTLS 握手，并携带这张有效的客户端证书。

这样一来，JWT 成了一次性的“门票”，用来换取一个有时效性的、绑定到设备的“通行证”（客户端证书）。即使 JWT 被窃取，由于它只能使用一次且生命周期极短，风险被大大降低。而攻击者如果想伪造业务请求，就必须同时窃取到客户端证书及其私钥，这比窃取一个存储在 LocalStorage 中的 JWT 要困难得多。

第一部分：构建 Go CA 与证书签发服务

一切的起点是拥有自己的证书颁发机构（CA）。在真实生产环境中，这通常由专用的密钥管理系统（如 HashiCorp Vault）或内部 PKI 基础设置来承担。但为了完整地展示原理，我们用 Go 来实现一个迷你 CA 服务。

首先，我们需要生成 CA 的根证书和私钥。这是一次性操作，生成的 ca.crt 和 ca.key 文件需要被妥善保管。

// cmd/setup_ca/main.go
// 这是一个一次性运行的脚本，用于生成根CA证书和私钥
package main

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

func main() {
	// 1. 生成CA的私钥
	caPrivKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
	if err != nil {
		log.Fatalf("生成CA私钥失败: %v", err)
	}

	// 2. 创建CA证书模板
	caTemplate := &x509.Certificate{
		SerialNumber: big.NewInt(2023),
		Subject: pkix.Name{
			Organization: []string{"My Corp"},
			Country:      []string{"CN"},
			Province:     []string{"Shanghai"},
			Locality:     []string{"Shanghai"},
			CommonName:   "My Corp Root CA",
		},
		NotBefore:             time.Now(),
		NotAfter:              time.Now().AddDate(10, 0, 0), // 有效期10年
		IsCA:                  true,
		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth},
		KeyUsage:              x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,
		BasicConstraintsValid: true,
	}

	// 3. 自签名生成CA证书
	caBytes, err := x509.CreateCertificate(rand.Reader, caTemplate, caTemplate, &caPrivKey.PublicKey, caPrivKey)
	if err != nil {
		log.Fatalf("创建CA证书失败: %v", err)
	}

	// 4. 将CA证书编码为PEM格式并保存到文件
	caPEM := pem.EncodeToMemory(&pem.Block{
		Type:  "CERTIFICATE",
		Bytes: caBytes,
	})
	if err := os.WriteFile("ca.crt", caPEM, 0644); err != nil {
		log.Fatalf("保存CA证书文件失败: %v", err)
	}
	log.Println("成功生成 ca.crt")

	// 5. 将CA私钥编码为PEM格式并保存到文件
	caPrivKeyBytes, err := x509.MarshalECPrivateKey(caPrivKey)
	if err != nil {
		log.Fatalf("序列化CA私钥失败: %v", err)
	}
	caPrivKeyPEM := pem.EncodeToMemory(&pem.Block{
		Type:  "EC PRIVATE KEY",
		Bytes: caPrivKeyBytes,
	})
	if err := os.WriteFile("ca.key", caPrivKeyPEM, 0600); err != nil {
		log.Fatalf("保存CA私钥文件失败: %v", err)
	}
	log.Println("成功生成 ca.key (请妥善保管此文件)")
}

有了 CA，我们就可以构建一个 HTTP 服务，它负责为通过验证的客户端签发短生命周期的证书。这个服务本身需要被保护，例如通过一个只有认证服务才能调用的内部网络，或者要求请求中携带我们之前提到的 Bootstrap JWT。

// pkg/certsigner/signer.go
package certsigner

import (
	"crypto/ecdsa"
	"crypto/elliptic"
	"crypto/rand"
	"crypto/tls"
	"crypto/x509"
	"crypto/x509/pkix"
	"encoding/pem"
	"errors"
	"fmt"
	"log"
	"math/big"
	"net/http"
	"time"
)

type CertSigner struct {
	caCert *x509.Certificate
	caKey  *ecdsa.PrivateKey
}

func NewCertSigner(caCertPath, caKeyPath string) (*CertSigner, error) {
	certPEM, err := os.ReadFile(caCertPath)
	if err != nil {
		return nil, fmt.Errorf("读取CA证书失败: %w", err)
	}
	keyPEM, err := os.ReadFile(caKeyPath)
	if err != nil {
		return nil, fmt.Errorf("读取CA私钥失败: %w", err)
	}
    
	// 使用辅助函数加载证书和密钥
	caTlsCert, err := tls.X509KeyPair(certPEM, keyPEM)
	if err != nil {
		return nil, fmt.Errorf("加载CA密钥对失败: %w", err)
	}

	caCert, err := x509.ParseCertificate(caTlsCert.Certificate[0])
	if err != nil {
		return nil, fmt.Errorf("解析CA证书失败: %w", err)
	}

	caKey, ok := caTlsCert.PrivateKey.(*ecdsa.PrivateKey)
	if !ok {
		return nil, errors.New("CA私钥类型不是ECDSA")
	}

	return &CertSigner{
		caCert: caCert,
		caKey:  caKey,
	}, nil
}

// issueClientCertificate 为给定的用户ID签发一个客户端证书
func (cs *CertSigner) issueClientCertificate(userID string) ([]byte, []byte, error) {
	// 1. 为客户端生成一个新的私钥
	clientPrivKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
	if err != nil {
		return nil, nil, fmt.Errorf("生成客户端私钥失败: %w", err)
	}
	
	clientPrivKeyBytes, err := x509.MarshalECPrivateKey(clientPrivKey)
	if err != nil {
		return nil, nil, fmt.Errorf("序列化客户端私钥失败: %w", err)
	}
	clientPrivKeyPEM := pem.EncodeToMemory(&pem.Block{
		Type:  "EC PRIVATE KEY",
		Bytes: clientPrivKeyBytes,
	})

	// 2. 创建客户端证书模板
	// 关键点：CN字段可以用来携带用户身份信息，有效期设置得很短
	certTemplate := &x509.Certificate{
		SerialNumber: big.NewInt(time.Now().UnixNano()),
		Subject: pkix.Name{
			Organization: []string{"My Corp Clients"},
			CommonName:   fmt.Sprintf("user-%s", userID),
		},
		NotBefore:   time.Now(),
		NotAfter:    time.Now().Add(1 * time.Hour), // 证书有效期仅1小时
		KeyUsage:    x509.KeyUsageDigitalSignature,
		ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth}, // 明确此证书用于客户端认证
	}

	// 3. 使用CA签发客户端证书
	clientCertBytes, err := x509.CreateCertificate(rand.Reader, certTemplate, cs.caCert, &clientPrivKey.PublicKey, cs.caKey)
	if err != nil {
		return nil, nil, fmt.Errorf("签发客户端证书失败: %w", err)
	}
	clientCertPEM := pem.EncodeToMemory(&pem.Block{
		Type:  "CERTIFICATE",
		Bytes: clientCertBytes,
	})

	return clientCertPEM, clientPrivKeyPEM, nil
}

// ServeHTTP 是处理证书签发请求的HTTP处理器
func (cs *CertSigner) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	// 在真实的系统中，这里需要一个严格的认证中间件
	// 例如，检查请求头中的Bootstrap JWT是否有效
	authToken := r.Header.Get("Authorization")
	if authToken == "" { // 极简化的认证检查
		http.Error(w, "缺少认证凭证", http.StatusUnauthorized)
		return
	}
	// 假设我们从JWT中解析出了userID
	userID := "user123" 
	log.Printf("收到来自用户 %s 的证书签发请求", userID)
	
	certPEM, keyPEM, err := cs.issueClientCertificate(userID)
	if err != nil {
		log.Printf("错误：为用户 %s 签发证书失败: %v", userID, err)
		http.Error(w, "内部服务器错误", http.StatusInternalServerError)
		return
	}
    
    // 返回证书和私钥。私钥绝不应该离开客户端，这里直接返回是为了演示
    // 在实际的伴侣代理模式中，代理请求并安全地存储私钥
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)
	response := fmt.Sprintf(`{"certificate": "%s", "private_key": "%s"}`, string(certPEM), string(keyPEM))
	w.Write([]byte(response))
}

第二部分：配置 Go mTLS 保护的业务 API

现在我们来构建真正的业务 API 服务。这个服务的关键在于其 http.Server 的 tls.Config 配置。我们必须强制要求并验证客户端证书。

// cmd/api_server/main.go
package main

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

// authMiddleware 验证mTLS连接并从证书中提取用户信息
func authMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		// mTLS握手成功后，客户端证书信息会出现在 r.TLS.PeerCertificates 中
		if r.TLS == nil || len(r.TLS.PeerCertificates) == 0 {
			log.Println("警告：拒绝了没有客户端证书的请求")
			http.Error(w, "需要客户端证书", http.StatusUnauthorized)
			return
		}

		// r.TLS.PeerCertificates[0] 是叶子证书，即客户端提供的证书
		clientCert := r.TLS.PeerCertificates[0]
		userID := clientCert.Subject.CommonName // 我们在签发时将用户信息放在了CN字段
		log.Printf("请求已授权：来自用户 %s, 证书颁发者: %s, 证书有效期至: %s", 
			userID, clientCert.Issuer.CommonName, clientCert.NotAfter.Format(time.RFC3339))
		
		// 可以在这里将用户信息注入到请求的context中，供下游handler使用
		// ctx := context.WithValue(r.Context(), "userID", userID)
		// next.ServeHTTP(w, r.WithContext(ctx))

		next.ServeHTTP(w, r)
	})
}

func helloHandler(w http.ResponseWriter, r *http.Request) {
	userID := r.TLS.PeerCertificates[0].Subject.CommonName
	fmt.Fprintf(w, "你好, %s! 你的请求已通过mTLS认证。", userID)
}

func main() {
	// 1. 加载 CA 证书，用于验证客户端证书的合法性
	caCertPEM, err := os.ReadFile("ca.crt")
	if err != nil {
		log.Fatalf("读取CA证书失败: %v", err)
	}
	caCertPool := x509.NewCertPool()
	if !caCertPool.AppendCertsFromPEM(caCertPEM) {
		log.Fatalf("无法将CA证书添加到证书池")
	}

	// 2. 配置 TLS
	// 这是整个mTLS方案的核心
	tlsConfig := &tls.Config{
		// ClientAuth 设置为 RequireAndVerifyClientCert
		// 这意味着服务器会要求客户端提供证书，并且会使用 ClientCAs 来验证该证书
		ClientAuth: tls.RequireAndVerifyClientCert,
		ClientCAs:  caCertPool, // 指定信任的CA池
		MinVersion: tls.VersionTLS12,
	}

	mux := http.NewServeMux()
	mux.Handle("/api/hello", authMiddleware(http.HandlerFunc(helloHandler)))

	server := &http.Server{
		Addr:      ":8443",
		Handler:   mux,
		TLSConfig: tlsConfig,
	}

	log.Println("mTLS API 服务器启动，监听端口 :8443")
	// 服务器自身的证书和私钥也需要提供
	// 为简化，可以签发一个 server.crt 和 server.key
	err = server.ListenAndServeTLS("server.crt", "server.key")
	if err != nil {
		log.Fatalf("服务器启动失败: %v", err)
	}
}

注意 tls.Config 中的 ClientAuth: tls.RequireAndVerifyClientCert，这是强制 mTLS 的关键。任何没有提供由我们 ca.crt 签发的有效证书的客户端连接，都会在 TLS 握手阶段被直接拒绝，根本不会进入我们的 HTTP handler 逻辑。

第三部分：客户端的实现：Angular 与伴侣代理

浏览器无法直接管理 TLS 连接所需的私钥和证书。因此，我们需要一个在本地运行的“伴侣代理”。这个代理负责所有与后端的 mTLS 通信，而 Angular 应用只需与这个本地代理进行简单的 HTTP 通信。

sequenceDiagram
    participant A as Angular SPA (in Browser)
    participant P as Local Companion Proxy
    participant S as Go mTLS API Server

    A->>P: HTTP GET /api/data (to localhost:9090)
    Note over P: 代理收到请求，检查本地是否有有效证书
    alt 证书无效或缺失
        P->>S: POST /auth/issue-cert (with Bootstrap JWT)
        S-->>P: Returns new short-lived client cert & key
        Note over P: 安全地存储证书和私钥
    end
    P->>S: mTLS Handshake
    Note over S,P: 服务器验证客户端证书
客户端验证服务器证书
    P->>S: HTTPS GET /api/data (with client cert)
    S-->>P: HTTPS 200 OK, returns data
    P-->>A: HTTP 200 OK, returns data

下面是一个极简的伴侣代理实现，同样使用 Go。

// cmd/companion_proxy/main.go
package main

import (
	"crypto/tls"
	"crypto/x509"
	"io"
	"log"
	"net/http"
	"net/http/httputil"
	"net/url"
	"os"
	"sync"
	"time"
)

var (
	clientCert tls.Certificate
	certMutex  sync.RWMutex
	certExpiry time.Time
)

// fetchAndStoreCertificate 负责从证书签发服务获取证书
func fetchAndStoreCertificate() error {
	// 实际应用中，这里需要先进行用户登录，获取 Bootstrap JWT
	bootstrapToken := "a-valid-bootstrap-jwt"

	req, _ := http.NewRequest("POST", "http://localhost:8080/issue-cert", nil)
	req.Header.Set("Authorization", "Bearer "+bootstrapToken)
	
	// 这里与签发服务的通信是普通HTTP，因为它在受信任的初始化流程中
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return fmt.Errorf("请求证书失败: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		body, _ := io.ReadAll(resp.Body)
		return fmt.Errorf("证书签发服务返回错误: %d - %s", resp.StatusCode, string(body))
	}
    
    var certData struct {
        Certificate string `json:"certificate"`
        PrivateKey  string `json:"private_key"`
    }
    if err := json.NewDecoder(resp.Body).Decode(&certData); err != nil {
        return fmt.Errorf("解析证书响应失败: %w", err)
    }

	cert, err := tls.X509KeyPair([]byte(certData.Certificate), []byte(certData.PrivateKey))
	if err != nil {
		return fmt.Errorf("加载新获取的密钥对失败: %w", err)
	}

	// 解析证书以获取有效期
	x509Cert, err := x509.ParseCertificate(cert.Certificate[0])
	if err != nil {
		return fmt.Errorf("解析新证书失败: %w", err)
	}

	certMutex.Lock()
	clientCert = cert
	certExpiry = x509Cert.NotAfter
	certMutex.Unlock()

	log.Printf("成功获取并加载新客户端证书，有效期至: %s", certExpiry.Format(time.RFC3339))
	return nil
}

// getClientCertificate is a callback for http.Transport to provide a client certificate
func getClientCertificate(info *tls.CertificateRequestInfo) (*tls.Certificate, error) {
	certMutex.RLock()
	defer certMutex.RUnlock()
	
	// 检查证书是否即将过期（例如，在过期前5分钟刷新）
	if time.Now().After(certExpiry.Add(-5 * time.Minute)) {
		// 释放读锁，尝试获取写锁来更新证书
		// 这是一个简化的实现，生产代码需要更复杂的锁机制防止惊群效应
		go func() {
			log.Println("客户端证书即将过期，尝试刷新...")
			if err := fetchAndStoreCertificate(); err != nil {
				log.Printf("错误：刷新证书失败: %v", err)
			}
		}()
	}

	return &clientCert, nil
}

func main() {
	// 初始启动时获取一次证书
	if err := fetchAndStoreCertificate(); err != nil {
		log.Fatalf("启动时获取证书失败: %v", err)
	}

	caCertPEM, err := os.ReadFile("ca.crt")
	if err != nil {
		log.Fatalf("读取CA证书失败: %v", err)
	}
	caCertPool := x509.NewCertPool()
	caCertPool.AppendCertsFromPEM(caCertPEM)

	// 配置代理的 HTTP Transport，使其能够处理 mTLS
	proxyTransport := &http.Transport{
		TLSClientConfig: &tls.Config{
			RootCAs:            caCertPool,
			// GetClientCertificate 在每次TLS握手时被调用
			// 这使得我们能够动态地提供和刷新证书
			GetClientCertificate: getClientCertificate,
		},
	}
	
	targetUrl, _ := url.Parse("https://localhost:8443")
	proxy := httputil.NewSingleHostReverseProxy(targetUrl)
	proxy.Transport = proxyTransport

	// 启动一个本地 HTTP 服务器，监听来自 Angular 应用的请求
	// 注意这里是 http，不是 https，因为是本地通信
	log.Println("伴侣代理启动，监听端口 :9090")
	if err := http.ListenAndServe(":9090", proxy); err != nil {
		log.Fatalf("代理服务器启动失败: %v", err)
	}
}

在 Angular 应用中，我们只需要将 API 的 baseURL 配置为指向本地代理即可。

// src/environments/environment.ts
export const environment = {
  production: false,
  apiUrl: 'http://localhost:9090/api' // 指向本地伴侣代理
};

// src/app/some.service.ts
import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { environment } from '../environments/environment';

@Injectable({ providedIn: 'root' })
export class SomeService {
  constructor(private http: HttpClient) {}

  getHelloMessage() {
    return this.http.get<string>(`${environment.apiUrl}/hello`, { responseType: 'text' as 'json' });
  }
}

现在，整个流程已经闭环。Angular 应用对开发者完全透明，它像往常一样发起 HTTP 请求。但这些请求被本地代理拦截，代理负责完成动态证书的获取、存储、刷新，并在每次与后端通信时执行 mTLS 握手。我们成功地将设备身份验证从应用层转移到了更可靠的传输层。

测试这个系统时，一个常见的错误是证书链问题。可以使用 openssl 或 curl 命令来调试 mTLS 连接：

# 使用获取到的客户端证书和私钥直接调用 mTLS API
curl --cacert ca.crt \
     --cert client.crt \
     --key client.key \
     https://localhost:8443/api/hello

如果命令成功返回 “你好, user-user123! …”, 则证明 mTLS 后端配置正确。如果失败，详细的错误信息通常能指出是证书不受信任、证书过期还是客户端未提供证书等问题。

方案的局限性与未来迭代

当前方案强依赖于一个在客户端本地运行的“伴侣代理”。这虽然在可控的企业桌面环境中是可行的（可以通过客户端管理软件统一部署），但对于开放的 Web 环境，它增加了用户侧的部署和维护复杂性。这不是一个普适于所有 Web 应用的方案。

对于纯浏览器环境，未来的探索方向可能在于利用 WebCrypto API 结合新兴的 Web 标准，但这目前还无法直接用于 TLS 握手。

此外，我们的实现通过极短的证书生命周期来规避了实现复杂证书吊销列表（CRL）或在线证书状态协议（OCSP）的需求。如果一个证书在一小时内就会过期，那么吊销它的需求就大大降低了。然而，这种策略对客户端和服务器的时钟同步有较高要求，否则可能导致证书因时钟偏差而被误判为无效。在未来的迭代中，如果业务场景需要更长的证书有效期，那么一套可靠、高效的证书吊销机制将是必须补充的。

Go mTLS Angular ZeroTrust Security

构建支持Oracle与MariaDB异构并存的微服务动态路由数据源

2023-10-27 架构设计

MariaDB Oracle 微服务框架 Nacos

一个内部开发者平台中数据湖查询层的架构选型与实现

2023-10-27 架构设计

Jest Go-Fiber Data Lake Android 开发 CSS Modules