474 lines
12 KiB
Go
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()
|
|
}
|