Files
yunzerwebsiteallinone/go/services/acme_cert.go
T
2026-11-16 17:22:50 +08:00

474 lines
12 KiB
Go

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"
issueFailureCooldown = 30 * time.Minute
issueTimeout = 3 * time.Minute
renewBeforeDays = 30
)
var (
challengeMu sync.RWMutex
challengeStore = make(map[string]string)
issueMu sync.Mutex
issuing = make(map[string]bool)
lastFailureAt = make(map[string]time.Time)
)
var challengeTokenRe = regexp.MustCompile(`^[A-Za-z0-9_-]{16,128}$`)
func challengeFilePath(token string) string {
return filepath.Join(SSLCertDir(), acmeChallengeDir, token)
}
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))
}
}
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)
}
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)
}
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
}
func newACMEClient(ctx context.Context) (*acme.Client, error) {
key, err := loadOrCreateAccountKey()
if err != nil {
return nil, err
}
client := &acme.Client{
Key: key,
DirectoryURL: acmeDirectoryURL(),
}
acct := &acme.Account{}
if email := acmeContactEmail(); email != "" {
acct.Contact = []string{"mailto:" + email}
}
if _, err := client.Register(ctx, acct, acme.AcceptTOS); err != nil && err != acme.ErrAccountAlreadyExists {
return nil, fmt.Errorf("注册 ACME 账号失败: %v", err)
}
return client, nil
}
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)
}
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)
}
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
}
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
}
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
}
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)
}
}
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)
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, ""
}
func updateSSLState(domainID uint64, sslStatus int, expireAt *time.Time, errMsg *string) {
msg := ""
if errMsg != nil {
msg = *errMsg
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)
}
}
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
}
}
}()
}
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
}
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)
}
}
}
func needsRenew(row models.SystemTenantDomain, deadline time.Time) bool {
if row.SSLStatus == models.SSLStatusIssuing {
return false
}
if row.SSLStatus != models.SSLStatusIssued {
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()
}