【调整】暗色主题样式

frontend/allinssl/backend/internal/cert/deploy/client/aliyun/aliyunCas.go

@@ -0,0 +1,42 @@
+package aliyun
+
+import (
+	aliyuncas "github.com/alibabacloud-go/cas-20200407/v4/client"
+	openapi "github.com/alibabacloud-go/darabonba-openapi/v2/client"
+	"github.com/alibabacloud-go/tea/tea"
+)
+
+type AliyunCasClient struct {
+	aliyuncas.Client
+}
+
+func ClientAliCas(accessKey, accessSecret string) (_result *AliyunCasClient, err error) {
+	config := &openapi.Config{
+		AccessKeyId:     tea.String(accessKey),
+		AccessKeySecret: tea.String(accessSecret),
+		Endpoint:        tea.String("cas.aliyuncs.com"),
+	}
+	casClient, err := aliyuncas.NewClient(config)
+	if err != nil {
+		return nil, err
+	}
+	
+	client := &AliyunCasClient{
+		Client: *casClient,
+	}
+	return client, nil
+}
+
+func (c *AliyunCasClient) UploadCert(certName, certContent, certKey string) (*int64, error) {
+	certificateRequest := &aliyuncas.UploadUserCertificateRequest{
+		Cert: tea.String(certContent),
+		Key:  tea.String(certKey),
+		Name: tea.String(certName),
+	}
+	uploadUserCertificateResp, err := c.UploadUserCertificate(certificateRequest)
+	if err != nil {
+		return nil, err
+	}
+	
+	return uploadUserCertificateResp.Body.CertId, nil
+}

frontend/allinssl/backend/internal/cert/deploy/client/aliyun/aliyunWaf.go

@@ -0,0 +1,292 @@
+package aliyun
+
+import (
+	"fmt"
+	openapi "github.com/alibabacloud-go/darabonba-openapi/v2/client"
+	openapiutil "github.com/alibabacloud-go/openapi-util/service"
+	util "github.com/alibabacloud-go/tea-utils/v2/service"
+	"github.com/alibabacloud-go/tea/tea"
+	aliyunwaf "github.com/alibabacloud-go/waf-openapi-20211001/v5/client"
+)
+
+type AliyunWafClient struct {
+	aliyunwaf.Client
+	accessKey    string
+	accessSecret string
+	region       string
+}
+
+func ClientAliWaf(accessKey, accessSecret, region string) (_result *AliyunWafClient, err error) {
+	//region:[cn-hangzhou,ap-southeast-1]
+
+	config := &openapi.Config{
+		AccessKeyId:     tea.String(accessKey),
+		AccessKeySecret: tea.String(accessSecret),
+		Endpoint:        tea.String(fmt.Sprintf("wafopenapi.%s.aliyuncs.com", region)),
+	}
+	client, err := aliyunwaf.NewClient(config)
+	if err != nil {
+		return nil, err
+	}
+
+	aliyunwafClient := &AliyunWafClient{
+		Client:       *client,
+		accessKey:    accessKey,
+		accessSecret: accessSecret,
+		region:       region,
+	}
+	return aliyunwafClient, nil
+}
+
+type CreateCertsResponseBody struct {
+	CertIdentifier *string `json:"CertIdentifier,omitempty" xml:"DomainInfo,omitempty"`
+	RequestId      *string `json:"RequestId,omitempty" xml:"RequestId,omitempty"`
+}
+
+type CreateCertsResponse struct {
+	Headers    map[string]*string       `json:"headers,omitempty" xml:"headers,omitempty"`
+	StatusCode *int32                   `json:"statusCode,omitempty" xml:"statusCode,omitempty"`
+	Body       *CreateCertsResponseBody `json:"body,omitempty" xml:"body,omitempty"`
+}
+
+func (client *AliyunWafClient) ICreateCerts(certName, certContent, certKey, instanceId string) (certId *string, _err error) {
+	query := map[string]interface{}{
+		"CertName":    certName,
+		"CertContent": certContent,
+		"CertKey":     certKey,
+		"InstanceId":  instanceId,
+	}
+
+	req := &openapi.OpenApiRequest{
+		Query: openapiutil.Query(query),
+	}
+	params := &openapi.Params{
+		Action:      tea.String("CreateCerts"),
+		Version:     tea.String("2021-10-01"),
+		Protocol:    tea.String("HTTPS"),
+		Pathname:    tea.String("/"),
+		Method:      tea.String("POST"),
+		AuthType:    tea.String("AK"),
+		Style:       tea.String("RPC"),
+		ReqBodyType: tea.String("formData"),
+		BodyType:    tea.String("json"),
+	}
+
+	createCertsResponse := &CreateCertsResponse{}
+	runtime := &util.RuntimeOptions{}
+	_body, _err := client.CallApi(params, req, runtime)
+	if _err != nil {
+		return nil, _err
+	}
+	_err = tea.Convert(_body, &createCertsResponse)
+	certId = createCertsResponse.Body.CertIdentifier
+	return certId, _err
+}
+
+func (client *AliyunWafClient) IGetInstanceId() (instanceId *string, _err error) {
+	req := &aliyunwaf.DescribeInstanceRequest{
+		RegionId: tea.String(client.region),
+	}
+	response, _err := client.DescribeInstance(req)
+	if _err != nil {
+		return nil, _err
+	}
+	instanceId = response.Body.InstanceId
+	if instanceId == nil || *instanceId == "" {
+		_err = fmt.Errorf("未找到WAF实例ID，请检查是否已创建WAF实例")
+		return nil, _err
+	}
+
+	return instanceId, _err
+}
+
+func (client *AliyunWafClient) IDescribeDomainDetail(instanceId, domain string) (describeDomainDetailResponseBody *aliyunwaf.DescribeDomainDetailResponseBody, _err error) {
+	req := &aliyunwaf.DescribeDomainDetailRequest{
+		InstanceId: tea.String(instanceId),
+		RegionId:   tea.String(client.region),
+		Domain:     tea.String(domain),
+	}
+	response, _err := client.DescribeDomainDetail(req)
+	if _err != nil {
+		return nil, _err
+	}
+	describeDomainDetailResponseBody = response.Body
+
+	return describeDomainDetailResponseBody, _err
+}
+
+func (client *AliyunWafClient) IUpdateDomain(domainDesc *aliyunwaf.DescribeDomainDetailResponseBody, instanceId, certId string) error {
+	modifyDomainReq := &aliyunwaf.ModifyDomainRequest{
+		InstanceId: tea.String(instanceId),
+		RegionId:   tea.String(client.region),
+		Domain:     domainDesc.Domain,
+		Listen:     &aliyunwaf.ModifyDomainRequestListen{CertId: tea.String(certId)},
+	}
+	assignDomain(domainDesc, modifyDomainReq)
+	_, err := client.ModifyDomain(modifyDomainReq)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func assignDomain(from *aliyunwaf.DescribeDomainDetailResponseBody, to *aliyunwaf.ModifyDomainRequest) *aliyunwaf.ModifyDomainRequest {
+	if from == nil {
+		return to
+	}
+
+	if from.Listen != nil {
+		if to.Listen == nil {
+			to.Listen = &aliyunwaf.ModifyDomainRequestListen{}
+		}
+
+		if from.Listen.CipherSuite != nil {
+			to.Listen.CipherSuite = tea.Int32(int32(*from.Listen.CipherSuite))
+		}
+
+		if from.Listen.CustomCiphers != nil {
+			to.Listen.CustomCiphers = from.Listen.CustomCiphers
+		}
+
+		if from.Listen.EnableTLSv3 != nil {
+			to.Listen.EnableTLSv3 = from.Listen.EnableTLSv3
+		}
+
+		if from.Listen.ExclusiveIp != nil {
+			to.Listen.ExclusiveIp = from.Listen.ExclusiveIp
+		}
+
+		if from.Listen.FocusHttps != nil {
+			to.Listen.FocusHttps = from.Listen.FocusHttps
+		}
+
+		if from.Listen.Http2Enabled != nil {
+			to.Listen.Http2Enabled = from.Listen.Http2Enabled
+		}
+
+		if from.Listen.IPv6Enabled != nil {
+			to.Listen.IPv6Enabled = from.Listen.IPv6Enabled
+		}
+
+		if from.Listen.ProtectionResource != nil {
+			to.Listen.ProtectionResource = from.Listen.ProtectionResource
+		}
+
+		if from.Listen.TLSVersion != nil {
+			to.Listen.TLSVersion = from.Listen.TLSVersion
+		}
+
+		if from.Listen.XffHeaderMode != nil {
+			to.Listen.XffHeaderMode = tea.Int32(int32(*from.Listen.XffHeaderMode))
+		}
+
+		if from.Listen.XffHeaders != nil {
+			to.Listen.XffHeaders = from.Listen.XffHeaders
+		}
+
+		if from.Listen.HttpPorts != nil {
+			to.Listen.HttpPorts = make([]*int32, len(from.Listen.HttpPorts))
+			for i, port := range from.Listen.HttpPorts {
+				if port != nil {
+					to.Listen.HttpPorts[i] = tea.Int32(int32(*port))
+				}
+			}
+		}
+
+		if from.Listen.HttpsPorts != nil {
+			to.Listen.HttpsPorts = make([]*int32, len(from.Listen.HttpsPorts))
+			for i, port := range from.Listen.HttpsPorts {
+				if port != nil {
+					to.Listen.HttpsPorts[i] = tea.Int32(int32(*port))
+				}
+			}
+		}
+
+	}
+
+	if from.Redirect != nil {
+		if to.Redirect == nil {
+			to.Redirect = &aliyunwaf.ModifyDomainRequestRedirect{}
+		}
+
+		if from.Redirect.ConnectTimeout != nil {
+			to.Redirect.ConnectTimeout = from.Redirect.ConnectTimeout
+		}
+
+		if from.Redirect.FocusHttpBackend != nil {
+			to.Redirect.FocusHttpBackend = from.Redirect.FocusHttpBackend
+		}
+
+		if from.Redirect.Keepalive != nil {
+			to.Redirect.Keepalive = from.Redirect.Keepalive
+		}
+
+		if from.Redirect.KeepaliveRequests != nil {
+			to.Redirect.KeepaliveRequests = from.Redirect.KeepaliveRequests
+		}
+
+		if from.Redirect.KeepaliveTimeout != nil {
+			to.Redirect.KeepaliveTimeout = from.Redirect.KeepaliveTimeout
+		}
+
+		if from.Redirect.Loadbalance != nil {
+			to.Redirect.Loadbalance = from.Redirect.Loadbalance
+		}
+
+		if from.Redirect.ReadTimeout != nil {
+			to.Redirect.ReadTimeout = from.Redirect.ReadTimeout
+		}
+
+		if from.Redirect.Retry != nil {
+			to.Redirect.Retry = from.Redirect.Retry
+		}
+
+		if from.Redirect.SniEnabled != nil {
+			to.Redirect.SniEnabled = from.Redirect.SniEnabled
+		}
+
+		if from.Redirect.SniHost != nil {
+			to.Redirect.SniHost = from.Redirect.SniHost
+		}
+
+		if from.Redirect.WriteTimeout != nil {
+			to.Redirect.WriteTimeout = from.Redirect.WriteTimeout
+		}
+
+		if from.Redirect.XffProto != nil {
+			to.Redirect.XffProto = from.Redirect.XffProto
+		}
+
+		if from.Redirect.Backends != nil {
+			to.Redirect.Backends = make([]*string, len(from.Redirect.Backends))
+			for i, backend := range from.Redirect.Backends {
+				if backend != nil {
+					to.Redirect.Backends[i] = backend.Backend
+				}
+			}
+		}
+
+		if from.Redirect.BackupBackends != nil {
+			to.Redirect.BackupBackends = make([]*string, len(from.Redirect.BackupBackends))
+			for i, backend := range from.Redirect.BackupBackends {
+				if backend != nil {
+					to.Redirect.BackupBackends[i] = backend.Backend
+				}
+			}
+		}
+
+		if from.Redirect.RequestHeaders != nil {
+			to.Redirect.RequestHeaders = make([]*aliyunwaf.ModifyDomainRequestRedirectRequestHeaders, len(from.Redirect.RequestHeaders))
+			for i, header := range from.Redirect.RequestHeaders {
+				if header != nil {
+					to.Redirect.RequestHeaders[i] = &aliyunwaf.ModifyDomainRequestRedirectRequestHeaders{
+						Key:   header.Key,
+						Value: header.Value,
+					}
+				}
+			}
+		}
+	}
+
+	return to
+}

frontend/allinssl/backend/internal/cert/deploy/client/baiduyun/baiduyunCdn.go

@@ -0,0 +1,35 @@
+package baiduyun
+
+import (
+	"fmt"
+	baiduyuncdn "github.com/baidubce/bce-sdk-go/services/cdn"
+	"github.com/baidubce/bce-sdk-go/services/cdn/api"
+)
+
+type BaiduyunCdnClient struct {
+	baiduyuncdn.Client
+}
+
+func ClientBaiduCdn(ak, sk string) (*BaiduyunCdnClient, error) {
+	client, err := baiduyuncdn.NewClient(ak, sk, "https://cdn.baidubce.com")
+	if err != nil {
+		return nil, err
+	}
+	baiduCdnClient := &BaiduyunCdnClient{
+		Client: *client,
+	}
+	return baiduCdnClient, nil
+}
+
+func (client *BaiduyunCdnClient) IPutCert(domain, certName, certContent, certKey string) (string, error) {
+	certId, err := client.PutCert(domain, &api.UserCertificate{
+		CertName:    certName,
+		ServerData:  certContent,
+		PrivateData: certKey,
+	}, "ON")
+	
+	if err != nil {
+		return "", fmt.Errorf("修改域名证书失败: %v", err)
+	}
+	return certId, nil
+}

frontend/allinssl/backend/internal/cert/deploy/client/volcengine/volcengineCdn.go

@@ -0,0 +1,75 @@
+package deploy
+
+import (
+	"fmt"
+	"github.com/volcengine/volcengine-go-sdk/service/cdn"
+	"github.com/volcengine/volcengine-go-sdk/volcengine"
+	"github.com/volcengine/volcengine-go-sdk/volcengine/credentials"
+	"github.com/volcengine/volcengine-go-sdk/volcengine/session"
+	"regexp"
+)
+
+type VolcEngineCdnClient struct {
+	*cdn.CDN
+}
+
+func createSdkSession(ak, sk, region string) (*session.Session, error) {
+	config := volcengine.NewConfig().
+		WithRegion(region).
+		WithCredentials(credentials.NewStaticCredentials(ak, sk, ""))
+	sess, err := session.NewSession(config)
+	if err != nil {
+		return nil, fmt.Errorf("创建火山引擎客户端失败: %w", err)
+	}
+	
+	return sess, err
+}
+
+func ClientVolcEngineCdn(ak, sk, region string) (*VolcEngineCdnClient, error) {
+	sess, err := createSdkSession(ak, sk, region)
+	if err != nil {
+		return nil, fmt.Errorf("创建火山引擎CDN客户端失败: %w", err)
+	}
+	cdnClient := &VolcEngineCdnClient{
+		CDN: cdn.New(sess),
+	}
+	return cdnClient, nil
+}
+
+func (v *VolcEngineCdnClient) IUploadCert(certContent, certKey string) (string, error) {
+	// 创建证书上传请求
+	input := &cdn.AddCertificateInput{
+		Certificate: volcengine.String(certContent),
+		PrivateKey:  volcengine.String(certKey),
+		Repeatable:  volcengine.Bool(false),
+		Source:      volcengine.String("volc_cert_center"),
+	}
+	
+	output, err := v.AddCertificate(input)
+	if err != nil {
+		if output.Metadata.Error.Code == "InvalidParameter.Certificate.Duplicated" {
+			re := regexp.MustCompile(`cert-[a-f0-9]{32}`)
+			certId := re.FindString(output.Metadata.Error.Message)
+			fmt.Printf("相同证书已存在 certId:%s\n", certId)
+			return certId, nil
+		}
+		return "", fmt.Errorf("上传证书失败: %w", err)
+	}
+	return *output.CertId, nil
+}
+
+func (v *VolcEngineCdnClient) IBatchDeployCert(certId, domain string) error {
+	batchDeployCertInput := &cdn.BatchDeployCertInput{
+		CertId: volcengine.String(certId),
+		Domain: volcengine.String(domain),
+	}
+	
+	res, err := v.BatchDeployCert(batchDeployCertInput)
+	if err != nil {
+		return fmt.Errorf("部署证书失败: %w", err)
+	}
+	if *res.DeployResult[0].Status != "success" {
+		return fmt.Errorf("部署证书失败: %s", *res.DeployResult[0].ErrorMsg)
+	}
+	return err
+}

frontend/allinssl/backend/internal/cert/deploy/client/volcengine/volcengineDCdn.go

@@ -0,0 +1,35 @@
+package deploy
+
+import (
+	"fmt"
+	"github.com/volcengine/volcengine-go-sdk/service/dcdn"
+	"github.com/volcengine/volcengine-go-sdk/volcengine"
+)
+
+type VolcEngineDcdnClient struct {
+	*dcdn.DCDN
+}
+
+func ClientVolcEngineDcdn(ak, sk, region string) (*VolcEngineDcdnClient, error) {
+	sess, err := createSdkSession(ak, sk, region)
+	if err != nil {
+		return nil, fmt.Errorf("创建火山引擎DCDN客户端失败: %w", err)
+	}
+	dcdnClient := &VolcEngineDcdnClient{
+		DCDN: dcdn.New(sess),
+	}
+	return dcdnClient, nil
+}
+
+func (v *VolcEngineDcdnClient) IDCDNCreateCertBindInput(certId, domain string) error {
+	createCertBindInput := &dcdn.CreateCertBindInput{
+		CertId:      volcengine.String(certId),
+		DomainNames: volcengine.StringSlice([]string{domain}),
+	}
+	
+	_, err := v.CreateCertBind(createCertBindInput)
+	if err != nil {
+		return fmt.Errorf("部署证书失败: %w", err)
+	}
+	return err
+}

frontend/allinssl/backend/internal/cert/deploy/client/volcengine/volcengineDCdn_test.go

@@ -0,0 +1,19 @@
+package deploy
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestVolcEngineDcdnClient_IDCDNCreateCertBindInput(t *testing.T) {
+	id := "cert-"
+	domain := "hsdcdn.xxxx.com"
+	
+	client, _ := ClientVolcEngineDcdn("", "==", "cn-north-1")
+	
+	err := client.IDCDNCreateCertBindInput(id, domain)
+	if err != nil {
+		fmt.Printf("err:%+v", err)
+		return
+	}
+}