增加自定义绑定域名

go/services/acme_cert.go

@@ -0,0 +1,528 @@
+package services
+
+import (
+	"context"
+	"crypto"
+	"crypto/ecdsa"
+	"crypto/elliptic"
+	"crypto/rand"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/pem"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"sync"
+	"time"
+
+	"server/models"
+
+	"github.com/beego/beego/v2/core/logs"
+	beego "github.com/beego/beego/v2/server/web"
+	"golang.org/x/crypto/acme"
+)
+
+const (
+	acmeAccountDir     = "_account"
+	acmeAccountKeyFile = "key.pem"
+	acmeChallengeDir   = "_challenges"
+	certFileName       = "fullchain.pem"
+	keyFileName        = "privkey.pem"
+
+	// 签发失败后的冷却时间。Let's Encrypt 对同一账号的验证失败次数有频控
+	// （每小时 5 次），冷却可避免租户反复点击把额度打满。
+	issueFailureCooldown = 30 * time.Minute
+
+	// 单次签发的整体超时。HTTP-01 需要等 CA 回访，给足时间但不能无限等。
+	issueTimeout = 3 * time.Minute
+
+	// 证书到期前多少天开始续期
+	renewBeforeDays = 30
+)
+
+var (
+	challengeMu    sync.RWMutex
+	challengeStore = make(map[string]string) // token -> keyAuthorization
+
+	issueMu       sync.Mutex
+	issuing       = make(map[string]bool)      // host -> 是否正在签发
+	lastFailureAt = make(map[string]time.Time) // host -> 最近一次签发失败时间
+)
+
+// ===== challenge 存取（供 /.well-known/acme-challenge/:token 路由使用）=====
+
+// challengeTokenRe ACME token 的合法字符集（base64url）。
+// token 会被拼进文件名，必须先校验，避免路径穿越。
+var challengeTokenRe = regexp.MustCompile(`^[A-Za-z0-9_-]{16,128}$`)
+
+func challengeFilePath(token string) string {
+	return filepath.Join(SSLCertDir(), acmeChallengeDir, token)
+}
+
+// GetHTTP01Challenge 返回 token 对应的 keyAuthorization。
+//
+// 先查内存，再查磁盘。磁盘这层是为拆进程部署准备的：签发是由 backend/platform
+// 接口触发的，而 CA 的回访只会落到 Nginx 扑底站点指向的那个进程，两者可能不是
+// 同一个进程，只靠内存会验证失败。
+func GetHTTP01Challenge(token string) (string, bool) {
+	challengeMu.RLock()
+	v, ok := challengeStore[token]
+	challengeMu.RUnlock()
+	if ok {
+		return v, true
+	}
+
+	if !challengeTokenRe.MatchString(token) {
+		return "", false
+	}
+	raw, err := os.ReadFile(challengeFilePath(token))
+	if err != nil {
+		return "", false
+	}
+	return strings.TrimSpace(string(raw)), true
+}
+
+func putHTTP01Challenge(token, keyAuth string) {
+	challengeMu.Lock()
+	challengeStore[token] = keyAuth
+	challengeMu.Unlock()
+
+	if !challengeTokenRe.MatchString(token) {
+		return
+	}
+	dir := filepath.Join(SSLCertDir(), acmeChallengeDir)
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		logs.Warn("[acme] 创建 challenge 目录失败（将只依赖内存）: %v", err)
+		return
+	}
+	if err := os.WriteFile(challengeFilePath(token), []byte(keyAuth), 0o644); err != nil {
+		logs.Warn("[acme] 写入 challenge 文件失败（将只依赖内存）: %v", err)
+	}
+}
+
+func deleteHTTP01Challenge(token string) {
+	challengeMu.Lock()
+	delete(challengeStore, token)
+	challengeMu.Unlock()
+
+	if challengeTokenRe.MatchString(token) {
+		_ = os.Remove(challengeFilePath(token))
+	}
+}
+
+// ===== 配置 =====
+
+// SSLCertDir 证书落盘根目录
+func SSLCertDir() string {
+	dir, _ := beego.AppConfig.String("ssl_cert_dir")
+	dir = strings.TrimSpace(dir)
+	if dir == "" {
+		dir = "/www/wwwroot/ssl-certs"
+	}
+	return dir
+}
+
+func acmeDirectoryURL() string {
+	u, _ := beego.AppConfig.String("acme_directory")
+	return strings.TrimSpace(u)
+}
+
+func acmeContactEmail() string {
+	e, _ := beego.AppConfig.String("acme_email")
+	return strings.TrimSpace(e)
+}
+
+// CertPaths 返回某域名的证书与私钥落盘路径。
+// host 会先做归一化：域名来自数据库，归一化可避免脏数据里的 ../ 之类写法拼出目录外的路径。
+func CertPaths(host string) (certPath, keyPath string) {
+	h := NormalizeHost(host)
+	if h == "" {
+		h = "_invalid"
+	}
+	base := filepath.Join(SSLCertDir(), h)
+	return filepath.Join(base, certFileName), filepath.Join(base, keyFileName)
+}
+
+// ===== ACME 账号 =====
+
+// loadOrCreateAccountKey 读取（或首次生成）ACME 账号私钥。
+// 账号私钥必须持久化：换了 key 等于换账号，历史签发记录和频控额度都会重置。
+func loadOrCreateAccountKey() (crypto.Signer, error) {
+	dir := filepath.Join(SSLCertDir(), acmeAccountDir)
+	path := filepath.Join(dir, acmeAccountKeyFile)
+
+	if raw, err := os.ReadFile(path); err == nil {
+		block, _ := pem.Decode(raw)
+		if block == nil {
+			return nil, fmt.Errorf("账号私钥格式错误: %s", path)
+		}
+		key, err := x509.ParseECPrivateKey(block.Bytes)
+		if err != nil {
+			return nil, fmt.Errorf("解析账号私钥失败: %v", err)
+		}
+		return key, nil
+	}
+
+	if err := os.MkdirAll(dir, 0o700); err != nil {
+		return nil, fmt.Errorf("创建账号目录失败: %v", err)
+	}
+	key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	if err != nil {
+		return nil, fmt.Errorf("生成账号私钥失败: %v", err)
+	}
+	der, err := x509.MarshalECPrivateKey(key)
+	if err != nil {
+		return nil, fmt.Errorf("序列化账号私钥失败: %v", err)
+	}
+	pemBytes := pem.EncodeToMemory(&pem.Block{Type: "EC PRIVATE KEY", Bytes: der})
+	if err := os.WriteFile(path, pemBytes, 0o600); err != nil {
+		return nil, fmt.Errorf("写入账号私钥失败: %v", err)
+	}
+	return key, nil
+}
+
+// newACMEClient 构造 ACME 客户端并确保账号已注册
+func newACMEClient(ctx context.Context) (*acme.Client, error) {
+	key, err := loadOrCreateAccountKey()
+	if err != nil {
+		return nil, err
+	}
+	client := &acme.Client{
+		Key:          key,
+		DirectoryURL: acmeDirectoryURL(), // 留空则 acme 包默认使用 Let's Encrypt 正式环境
+	}
+
+	acct := &acme.Account{}
+	if email := acmeContactEmail(); email != "" {
+		acct.Contact = []string{"mailto:" + email}
+	}
+	// 已注册过会返回 ErrAccountAlreadyExists，属于正常情况
+	if _, err := client.Register(ctx, acct, acme.AcceptTOS); err != nil && err != acme.ErrAccountAlreadyExists {
+		return nil, fmt.Errorf("注册 ACME 账号失败: %v", err)
+	}
+	return client, nil
+}
+
+// ===== 证书签发 =====
+
+// obtainCertificate 走完整的 HTTP-01 流程拿到证书并落盘，返回证书到期时间。
+func obtainCertificate(ctx context.Context, host string) (time.Time, error) {
+	client, err := newACMEClient(ctx)
+	if err != nil {
+		return time.Time{}, err
+	}
+
+	order, err := client.AuthorizeOrder(ctx, acme.DomainIDs(host))
+	if err != nil {
+		return time.Time{}, fmt.Errorf("创建证书订单失败: %v", err)
+	}
+
+	// 逐个完成 pending 的授权
+	for _, authzURL := range order.AuthzURLs {
+		authz, err := client.GetAuthorization(ctx, authzURL)
+		if err != nil {
+			return time.Time{}, fmt.Errorf("获取授权信息失败: %v", err)
+		}
+		if authz.Status != acme.StatusPending {
+			continue
+		}
+
+		var chal *acme.Challenge
+		for _, c := range authz.Challenges {
+			if c.Type == "http-01" {
+				chal = c
+				break
+			}
+		}
+		if chal == nil {
+			return time.Time{}, fmt.Errorf("证书颁发机构未提供 http-01 验证方式")
+		}
+
+		keyAuth, err := client.HTTP01ChallengeResponse(chal.Token)
+		if err != nil {
+			return time.Time{}, fmt.Errorf("生成验证响应失败: %v", err)
+		}
+		putHTTP01Challenge(chal.Token, keyAuth)
+
+		if _, err := client.Accept(ctx, chal); err != nil {
+			deleteHTTP01Challenge(chal.Token)
+			return time.Time{}, fmt.Errorf("提交验证失败: %v", err)
+		}
+		_, err = client.WaitAuthorization(ctx, authz.URI)
+		deleteHTTP01Challenge(chal.Token)
+		if err != nil {
+			return time.Time{}, fmt.Errorf("域名验证未通过（请确认 80 端口可从公网访问且未强制跳转 HTTPS）: %v", err)
+		}
+	}
+
+	if _, err := client.WaitOrder(ctx, order.URI); err != nil {
+		return time.Time{}, fmt.Errorf("订单未就绪: %v", err)
+	}
+
+	// 生成证书私钥与 CSR
+	certKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	if err != nil {
+		return time.Time{}, fmt.Errorf("生成证书私钥失败: %v", err)
+	}
+	csrDER, err := x509.CreateCertificateRequest(rand.Reader, &x509.CertificateRequest{
+		Subject:  pkix.Name{CommonName: host},
+		DNSNames: []string{host},
+	}, certKey)
+	if err != nil {
+		return time.Time{}, fmt.Errorf("生成 CSR 失败: %v", err)
+	}
+
+	chainDER, _, err := client.CreateOrderCert(ctx, order.FinalizeURL, csrDER, true)
+	if err != nil {
+		return time.Time{}, fmt.Errorf("签发证书失败: %v", err)
+	}
+	if len(chainDER) == 0 {
+		return time.Time{}, fmt.Errorf("证书颁发机构返回了空证书链")
+	}
+
+	leaf, err := x509.ParseCertificate(chainDER[0])
+	if err != nil {
+		return time.Time{}, fmt.Errorf("解析证书失败: %v", err)
+	}
+
+	if err := writeCertFiles(host, chainDER, certKey); err != nil {
+		return time.Time{}, err
+	}
+	return leaf.NotAfter, nil
+}
+
+// writeCertFiles 把证书链与私钥写入 {ssl_cert_dir}/{host}/。
+// 先写临时文件再 rename，避免 nginx 读到写了一半的文件。
+func writeCertFiles(host string, chainDER [][]byte, key *ecdsa.PrivateKey) error {
+	certPath, keyPath := CertPaths(host)
+	dir := filepath.Dir(certPath)
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		return fmt.Errorf("创建证书目录失败: %v", err)
+	}
+
+	var chainPEM strings.Builder
+	for _, der := range chainDER {
+		if err := pem.Encode(&chainPEM, &pem.Block{Type: "CERTIFICATE", Bytes: der}); err != nil {
+			return fmt.Errorf("编码证书失败: %v", err)
+		}
+	}
+	if err := writeFileAtomic(certPath, []byte(chainPEM.String()), 0o644); err != nil {
+		return fmt.Errorf("写入证书失败: %v", err)
+	}
+
+	keyDER, err := x509.MarshalECPrivateKey(key)
+	if err != nil {
+		return fmt.Errorf("序列化证书私钥失败: %v", err)
+	}
+	keyPEM := pem.EncodeToMemory(&pem.Block{Type: "EC PRIVATE KEY", Bytes: keyDER})
+	if err := writeFileAtomic(keyPath, keyPEM, 0o600); err != nil {
+		return fmt.Errorf("写入证书私钥失败: %v", err)
+	}
+	return nil
+}
+
+func writeFileAtomic(path string, data []byte, perm os.FileMode) error {
+	tmp := path + ".tmp"
+	if err := os.WriteFile(tmp, data, perm); err != nil {
+		return err
+	}
+	// Linux 上 rename 覆盖同名文件是原子的，nginx 不会读到半个文件。
+	// Windows 上 rename 到已存在文件会失败，才退回「先删再改名」。
+	if err := os.Rename(tmp, path); err != nil {
+		_ = os.Remove(path)
+		if err2 := os.Rename(tmp, path); err2 != nil {
+			_ = os.Remove(tmp)
+			return err2
+		}
+	}
+	return nil
+}
+
+// ===== 与域名记录联动 =====
+
+// tryLockIssue 抢占某域名的签发权。返回 false 表示正在签发或处于失败冷却期。
+func tryLockIssue(host string) (bool, string) {
+	issueMu.Lock()
+	defer issueMu.Unlock()
+
+	if issuing[host] {
+		return false, "该域名正在签发证书，请稍后查看结果"
+	}
+	if at, ok := lastFailureAt[host]; ok {
+		if wait := issueFailureCooldown - time.Since(at); wait > 0 {
+			return false, fmt.Sprintf("上次签发失败，请在 %d 分钟后重试", int(wait.Minutes())+1)
+		}
+	}
+	issuing[host] = true
+	return true, ""
+}
+
+func unlockIssue(host string, failed bool) {
+	issueMu.Lock()
+	defer issueMu.Unlock()
+	delete(issuing, host)
+	if failed {
+		lastFailureAt[host] = time.Now()
+	} else {
+		delete(lastFailureAt, host)
+	}
+}
+
+// IssueCertificateAsync 异步为域名记录签发证书。
+// 立即返回；成功后把记录置为 ssl_status=2 且 status=1（已生效）。
+// 返回 false 表示当前不可发起（正在签发或冷却中），第二个返回值为原因。
+func IssueCertificateAsync(domainID uint64, host string) (bool, string) {
+	host = NormalizeHost(host)
+	if host == "" {
+		return false, "域名格式不正确"
+	}
+	ok, reason := tryLockIssue(host)
+	if !ok {
+		return false, reason
+	}
+
+	updateSSLState(domainID, models.SSLStatusIssuing, nil, nil)
+
+	go func() {
+		ctx, cancel := context.WithTimeout(context.Background(), issueTimeout)
+		defer cancel()
+
+		expireAt, err := obtainCertificate(ctx, host)
+		if err != nil {
+			logs.Error("[acme] 签发证书失败 host=%s: %v", host, err)
+			msg := err.Error()
+			updateSSLState(domainID, models.SSLStatusFailed, nil, &msg)
+			unlockIssue(host, true)
+			return
+		}
+
+		logs.Info("[acme] 签发证书成功 host=%s 到期=%s", host, expireAt.Format("2006-01-02"))
+		updateSSLState(domainID, models.SSLStatusIssued, &expireAt, nil)
+		// 证书就绪，域名正式生效。
+		// 只把「待生效(0)」推到「已生效(1)」：被平台禁用(2)的记录不能靠续期自己复活。
+		now := time.Now()
+		if _, err := models.Orm.QueryTable(new(models.SystemTenantDomain)).
+			Filter("id", domainID).
+			Filter("status", 0).
+			Filter("delete_time__isnull", true).
+			Update(map[string]interface{}{"status": 1, "update_time": now}); err != nil {
+			logs.Error("[acme] 更新域名生效状态失败 id=%d: %v", domainID, err)
+		}
+		unlockIssue(host, false)
+	}()
+
+	return true, ""
+}
+
+// updateSSLState 更新证书状态字段。
+// 注意：beego ORM 的 Update 会对参数做 reflect 解引用，直接塞 nil 的 *string 会 panic，
+// 因此这里统一转成空字符串 / 显式值。
+func updateSSLState(domainID uint64, sslStatus int, expireAt *time.Time, errMsg *string) {
+	msg := ""
+	if errMsg != nil {
+		msg = *errMsg
+		// ssl_error 字段 varchar(500)，超长会被 MySQL 严格模式拒绝
+		if len(msg) > 480 {
+			msg = msg[:480]
+		}
+	}
+	values := map[string]interface{}{
+		"ssl_status":  sslStatus,
+		"ssl_error":   msg,
+		"update_time": time.Now(),
+	}
+	if expireAt != nil {
+		values["ssl_expire_at"] = *expireAt
+	}
+	if _, err := models.Orm.QueryTable(new(models.SystemTenantDomain)).
+		Filter("id", domainID).
+		Filter("delete_time__isnull", true).
+		Update(values); err != nil {
+		logs.Error("[acme] 更新证书状态失败 id=%d: %v", domainID, err)
+	}
+}
+
+// ===== 续期调度 =====
+
+// StartCertRenewScheduler 启动证书续期调度：启动 1 分钟后跑一次，之后每 12 小时扫一次。
+func StartCertRenewScheduler(stopChan chan struct{}) {
+	go func() {
+		// 启动稍等，避开数据库初始化与首屏请求高峰
+		firstRun := time.NewTimer(1 * time.Minute)
+		defer firstRun.Stop()
+		select {
+		case <-firstRun.C:
+			renewExpiringCertificates()
+		case <-stopChan:
+			return
+		}
+
+		ticker := time.NewTicker(12 * time.Hour)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-ticker.C:
+				renewExpiringCertificates()
+			case <-stopChan:
+				return
+			}
+		}
+	}()
+}
+
+// renewExpiringCertificates 扫描自有域名，为「即将到期」「证书文件缺失」「之前失败」的记录重新签发。
+// 已生效域名续期失败不会下线站点，只写 ssl_error 等下一轮重试。
+func renewExpiringCertificates() {
+	var rows []models.SystemTenantDomain
+	_, err := models.Orm.QueryTable(new(models.SystemTenantDomain)).
+		Filter("domain_type", models.DomainTypeCustom).
+		Filter("delete_time__isnull", true).
+		Exclude("status", 2). // 已禁用的不续
+		All(&rows)
+	if err != nil {
+		logs.Error("[acme] 扫描待续期域名失败: %v", err)
+		return
+	}
+
+	deadline := time.Now().AddDate(0, 0, renewBeforeDays)
+	for i := range rows {
+		row := rows[i]
+		if row.FullDomain == nil || *row.FullDomain == "" {
+			continue
+		}
+		// DNS 还没通过的不去打 CA，避免浪费频控额度
+		if row.VerifyStatus != models.VerifyStatusPassed {
+			continue
+		}
+		if !needsRenew(row, deadline) {
+			continue
+		}
+		if ok, reason := IssueCertificateAsync(row.ID, *row.FullDomain); !ok {
+			logs.Info("[acme] 跳过续期 host=%s: %s", *row.FullDomain, reason)
+		}
+	}
+}
+
+// needsRenew 判断一条记录是否需要（重新）签发
+func needsRenew(row models.SystemTenantDomain, deadline time.Time) bool {
+	if row.SSLStatus == models.SSLStatusIssuing {
+		return false
+	}
+	if row.SSLStatus != models.SSLStatusIssued {
+		// 待处理或曾失败：重试（失败冷却由 tryLockIssue 兜住）
+		return true
+	}
+	// 证书文件被误删也要补签
+	certPath, keyPath := CertPaths(*row.FullDomain)
+	if !fileExists(certPath) || !fileExists(keyPath) {
+		return true
+	}
+	return row.SSLExpireAt == nil || row.SSLExpireAt.Before(deadline)
+}
+
+func fileExists(path string) bool {
+	info, err := os.Stat(path)
+	return err == nil && !info.IsDir()
+}