nick.adam/certigo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Activity

upload all

Browse Source
This commit is contained in:
Nick Adam
2025-11-20 13:29:13 +01:00
parent daea26583b
commit c0e2df2430
35 changed files with 10016 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
backend/providers/autodns.go Normal file
View File

@@ -0,0 +1,76 @@
package providers
import (
"fmt"
"strings"
)
// AutoDNSProvider ist der Provider für AutoDNS
type AutoDNSProvider struct{}
func NewAutoDNSProvider() *AutoDNSProvider {
return &AutoDNSProvider{}
}
func (p *AutoDNSProvider) GetName() string {
return "autodns"
}
func (p *AutoDNSProvider) GetDisplayName() string {
return "AutoDNS"
}
func (p *AutoDNSProvider) GetDescription() string {
return "AutoDNS SSL Certificate Provider"
}
func (p *AutoDNSProvider) ValidateConfig(settings map[string]interface{}) error {
username, ok := settings["username"].(string)
if !ok || strings.TrimSpace(username) == "" {
return fmt.Errorf("username ist erforderlich")
}
password, ok := settings["password"].(string)
if !ok || strings.TrimSpace(password) == "" {
return fmt.Errorf("password ist erforderlich")
}
return nil
}
func (p *AutoDNSProvider) TestConnection(settings map[string]interface{}) error {
// Hier würde die tatsächliche Verbindung zu AutoDNS getestet werden
// Für jetzt nur Validierung
return p.ValidateConfig(settings)
}
// GetRequiredSettings gibt die erforderlichen Einstellungen zurück
func (p *AutoDNSProvider) GetRequiredSettings() []SettingField {
return []SettingField{
{
Name: "username",
Label: "Benutzername",
Type: "text",
Required: true,
Description: "AutoDNS Benutzername",
},
{
Name: "password",
Label: "Passwort",
Type: "password",
Required: true,
Description: "AutoDNS Passwort",
},
}
}
// SignCSR signiert einen CSR (noch nicht implementiert)
func (p *AutoDNSProvider) SignCSR(csrPEM string, settings map[string]interface{}) (*SignCSRResult, error) {
return nil, fmt.Errorf("AutoDNS CSR-Signierung noch nicht implementiert")
}
// GetCertificate ruft ein Zertifikat ab (noch nicht implementiert)
func (p *AutoDNSProvider) GetCertificate(certificateID string, settings map[string]interface{}) (string, error) {
return "", fmt.Errorf("AutoDNS Zertifikat-Abruf noch nicht implementiert")
}

205
backend/providers/dummy.go Normal file
View File

@@ -0,0 +1,205 @@
package providers
import (
"bytes"
"encoding/base64"
"encoding/json"
"fmt"
"io"
"net/http"
"strings"
)
// DummyCAProvider ist ein Dummy-Provider für Tests
type DummyCAProvider struct {
baseURL string
}
func NewDummyCAProvider() *DummyCAProvider {
return &DummyCAProvider{
baseURL: "http://localhost:8088",
}
}
func (p *DummyCAProvider) GetName() string {
return "dummy-ca"
}
func (p *DummyCAProvider) GetDisplayName() string {
return "Dummy CA"
}
func (p *DummyCAProvider) GetDescription() string {
return "Externe Dummy CA für Tests und Entwicklung (http://localhost:8088)"
}
func (p *DummyCAProvider) ValidateConfig(settings map[string]interface{}) error {
// Dummy-Provider benötigt keine Konfiguration
return nil
}
func (p *DummyCAProvider) TestConnection(settings map[string]interface{}) error {
// Teste Verbindung zur externen CA über Health Check
url := fmt.Sprintf("%s/health", p.baseURL)
resp, err := http.Get(url)
if err != nil {
return fmt.Errorf("CA-Server nicht erreichbar: %v", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return fmt.Errorf("CA-Server antwortet mit Status %d", resp.StatusCode)
}
// Prüfe Response Body
body, err := io.ReadAll(resp.Body)
if err != nil {
return fmt.Errorf("fehler beim Lesen der Health-Check-Response: %v", err)
}
var healthResponse struct {
Status string `json:"status"`
}
if err := json.Unmarshal(body, &healthResponse); err != nil {
return fmt.Errorf("ungültige Health-Check-Response: %v", err)
}
if healthResponse.Status != "ok" {
return fmt.Errorf("CA-Server meldet Status: %s", healthResponse.Status)
}
return nil
}
// GetRequiredSettings gibt die erforderlichen Einstellungen zurück
func (p *DummyCAProvider) GetRequiredSettings() []SettingField {
return []SettingField{}
}
// SignCSR signiert einen CSR über die externe Dummy CA API
func (p *DummyCAProvider) SignCSR(csrPEM string, settings map[string]interface{}) (*SignCSRResult, error) {
// Entferne mögliche Whitespace am Anfang/Ende
csrPEM = strings.TrimSpace(csrPEM)
// Base64-kodiere den CSR
csrB64 := base64.StdEncoding.EncodeToString([]byte(csrPEM))
// Erstelle Request Body
requestBody := map[string]interface{}{
"csr": csrB64,
"action": "sign",
"validity_days": 365,
}
// Konvertiere zu JSON
jsonData, err := json.Marshal(requestBody)
if err != nil {
return nil, fmt.Errorf("fehler beim Erstellen des Request-Body: %v", err)
}
// Erstelle HTTP Request
url := fmt.Sprintf("%s/csr", p.baseURL)
req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
if err != nil {
return nil, fmt.Errorf("fehler beim Erstellen des HTTP-Requests: %v", err)
}
req.Header.Set("Content-Type", "application/json")
// Führe Request aus
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return nil, fmt.Errorf("fehler beim Senden des Requests an die CA: %v", err)
}
defer resp.Body.Close()
// Lese Response Body
body, err := io.ReadAll(resp.Body)
if err != nil {
return nil, fmt.Errorf("fehler beim Lesen der Response: %v", err)
}
// Prüfe Status Code
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("CA-API Fehler (Status %d): %s", resp.StatusCode, string(body))
}
// Parse Response
var apiResponse struct {
ID string `json:"id"`
Status string `json:"status"`
Message string `json:"message"`
Certificate string `json:"certificate"`
Error string `json:"error"`
}
if err := json.Unmarshal(body, &apiResponse); err != nil {
return nil, fmt.Errorf("fehler beim Parsen der Response: %v", err)
}
// Prüfe auf Fehler in der Response
if apiResponse.Error != "" {
return nil, fmt.Errorf("CA-API Fehler: %s", apiResponse.Error)
}
// Prüfe Status
if apiResponse.Status != "success" {
return nil, fmt.Errorf("CSR-Signierung fehlgeschlagen: %s", apiResponse.Message)
}
// Rückgabe des Ergebnisses
return &SignCSRResult{
CertificatePEM: apiResponse.Certificate,
OrderID: apiResponse.ID,
Status: "issued",
Message: apiResponse.Message,
}, nil
}
// GetCertificate ruft ein Zertifikat über die externe Dummy CA API ab
func (p *DummyCAProvider) GetCertificate(certificateID string, settings map[string]interface{}) (string, error) {
if certificateID == "" {
return "", fmt.Errorf("zertifikat-ID ist erforderlich")
}
// Erstelle HTTP Request
url := fmt.Sprintf("%s/certificate/%s", p.baseURL, certificateID)
resp, err := http.Get(url)
if err != nil {
return "", fmt.Errorf("fehler beim Abrufen des Zertifikats: %v", err)
}
defer resp.Body.Close()
// Lese Response Body
body, err := io.ReadAll(resp.Body)
if err != nil {
return "", fmt.Errorf("fehler beim Lesen der Response: %v", err)
}
// Prüfe Status Code
if resp.StatusCode == http.StatusNotFound {
return "", fmt.Errorf("Zertifikat mit ID %s nicht gefunden", certificateID)
}
if resp.StatusCode != http.StatusOK {
return "", fmt.Errorf("CA-API Fehler (Status %d): %s", resp.StatusCode, string(body))
}
// Parse Response
var apiResponse struct {
ID string `json:"id"`
Certificate string `json:"certificate"`
CreatedAt string `json:"created_at"`
}
if err := json.Unmarshal(body, &apiResponse); err != nil {
return "", fmt.Errorf("fehler beim Parsen der Response: %v", err)
}
if apiResponse.Certificate == "" {
return "", fmt.Errorf("zertifikat in Response nicht gefunden")
}
return apiResponse.Certificate, nil
}

63
backend/providers/hetzner.go Normal file
View File

@@ -0,0 +1,63 @@
package providers
import (
"fmt"
"strings"
)
// HetznerProvider ist der Provider für Hetzner
type HetznerProvider struct{}
func NewHetznerProvider() *HetznerProvider {
return &HetznerProvider{}
}
func (p *HetznerProvider) GetName() string {
return "hetzner"
}
func (p *HetznerProvider) GetDisplayName() string {
return "Hetzner"
}
func (p *HetznerProvider) GetDescription() string {
return "Hetzner SSL Certificate Provider"
}
func (p *HetznerProvider) ValidateConfig(settings map[string]interface{}) error {
apiKey, ok := settings["apiKey"].(string)
if !ok || strings.TrimSpace(apiKey) == "" {
return fmt.Errorf("apiKey ist erforderlich")
}
return nil
}
func (p *HetznerProvider) TestConnection(settings map[string]interface{}) error {
// Hier würde die tatsächliche Verbindung zu Hetzner getestet werden
// Für jetzt nur Validierung
return p.ValidateConfig(settings)
}
// GetRequiredSettings gibt die erforderlichen Einstellungen zurück
func (p *HetznerProvider) GetRequiredSettings() []SettingField {
return []SettingField{
{
Name: "apiKey",
Label: "API Key",
Type: "password",
Required: true,
Description: "Hetzner API Key",
},
}
}
// SignCSR signiert einen CSR (noch nicht implementiert)
func (p *HetznerProvider) SignCSR(csrPEM string, settings map[string]interface{}) (*SignCSRResult, error) {
return nil, fmt.Errorf("Hetzner CSR-Signierung noch nicht implementiert")
}
// GetCertificate ruft ein Zertifikat ab (noch nicht implementiert)
func (p *HetznerProvider) GetCertificate(certificateID string, settings map[string]interface{}) (string, error) {
return "", fmt.Errorf("Hetzner Zertifikat-Abruf noch nicht implementiert")
}

214
backend/providers/provider.go Normal file
View File

@@ -0,0 +1,214 @@
package providers
import (
"encoding/json"
"fmt"
"os"
"path/filepath"
"sync"
)
// ProviderConfig enthält die Konfiguration eines Providers
type ProviderConfig struct {
Enabled bool `json:"enabled"`
Settings map[string]interface{} `json:"settings"`
}
// SignCSRResult enthält das Ergebnis einer CSR-Signierung
type SignCSRResult struct {
CertificatePEM string `json:"certificatePEM"`
OrderID string `json:"orderId,omitempty"`
Status string `json:"status"`
Message string `json:"message,omitempty"`
}
// Provider Interface für alle SSL Certificate Provider
type Provider interface {
// GetName gibt den Namen des Providers zurück
GetName() string
// GetDisplayName gibt den Anzeigenamen zurück
GetDisplayName() string
// GetDescription gibt eine Beschreibung zurück
GetDescription() string
// ValidateConfig validiert die Konfiguration
ValidateConfig(settings map[string]interface{}) error
// TestConnection testet die Verbindung zum Provider
TestConnection(settings map[string]interface{}) error
// GetRequiredSettings gibt die erforderlichen Einstellungen zurück
GetRequiredSettings() []SettingField
// SignCSR signiert einen CSR und gibt das Zertifikat zurück
SignCSR(csrPEM string, settings map[string]interface{}) (*SignCSRResult, error)
// GetCertificate ruft ein Zertifikat anhand der Zertifikat-ID ab
GetCertificate(certificateID string, settings map[string]interface{}) (string, error)
}
// ProviderManager verwaltet alle Provider
type ProviderManager struct {
providers map[string]Provider
configs map[string]*ProviderConfig
configDir string
mu sync.RWMutex
}
var manager *ProviderManager
var once sync.Once
// GetManager gibt die Singleton-Instanz des ProviderManagers zurück
func GetManager() *ProviderManager {
once.Do(func() {
manager = &ProviderManager{
providers: make(map[string]Provider),
configs: make(map[string]*ProviderConfig),
configDir: "./config/providers",
}
manager.loadAllConfigs()
})
return manager
}
// RegisterProvider registriert einen neuen Provider
func (pm *ProviderManager) RegisterProvider(provider Provider) {
pm.mu.Lock()
defer pm.mu.Unlock()
providerID := pm.getProviderID(provider.GetName())
pm.providers[providerID] = provider
// Lade Konfiguration falls vorhanden
if pm.configs[providerID] == nil {
pm.configs[providerID] = &ProviderConfig{
Enabled: false,
Settings: make(map[string]interface{}),
}
}
}
// GetProvider gibt einen Provider zurück
func (pm *ProviderManager) GetProvider(id string) (Provider, bool) {
pm.mu.RLock()
defer pm.mu.RUnlock()
provider, exists := pm.providers[id]
return provider, exists
}
// GetAllProviders gibt alle registrierten Provider zurück
func (pm *ProviderManager) GetAllProviders() map[string]Provider {
pm.mu.RLock()
defer pm.mu.RUnlock()
result := make(map[string]Provider)
for id, provider := range pm.providers {
result[id] = provider
}
return result
}
// GetProviderConfig gibt die Konfiguration eines Providers zurück
func (pm *ProviderManager) GetProviderConfig(id string) (*ProviderConfig, error) {
pm.mu.RLock()
defer pm.mu.RUnlock()
config, exists := pm.configs[id]
if !exists {
return &ProviderConfig{
Enabled: false,
Settings: make(map[string]interface{}),
}, nil
}
return config, nil
}
// UpdateProviderConfig aktualisiert die Konfiguration eines Providers
func (pm *ProviderManager) UpdateProviderConfig(id string, config *ProviderConfig) error {
pm.mu.Lock()
defer pm.mu.Unlock()
provider, exists := pm.providers[id]
if !exists {
return fmt.Errorf("provider %s nicht gefunden", id)
}
// Validiere Konfiguration
if err := provider.ValidateConfig(config.Settings); err != nil {
return fmt.Errorf("ungültige Konfiguration: %v", err)
}
pm.configs[id] = config
// Speichere Konfiguration in Datei
return pm.saveConfig(id, config)
}
// SetProviderEnabled aktiviert/deaktiviert einen Provider
func (pm *ProviderManager) SetProviderEnabled(id string, enabled bool) error {
pm.mu.Lock()
defer pm.mu.Unlock()
if pm.configs[id] == nil {
pm.configs[id] = &ProviderConfig{
Enabled: enabled,
Settings: make(map[string]interface{}),
}
} else {
pm.configs[id].Enabled = enabled
}
return pm.saveConfig(id, pm.configs[id])
}
// getProviderID erstellt eine ID aus dem Provider-Namen
func (pm *ProviderManager) getProviderID(name string) string {
return name
}
// loadAllConfigs lädt alle Konfigurationsdateien
func (pm *ProviderManager) loadAllConfigs() {
// Stelle sicher, dass das Verzeichnis existiert
os.MkdirAll(pm.configDir, 0755)
// Lade alle JSON-Dateien im Konfigurationsverzeichnis
files, err := filepath.Glob(filepath.Join(pm.configDir, "*.json"))
if err != nil {
return
}
for _, file := range files {
id := filepath.Base(file[:len(file)-5]) // Entferne .json
config, err := pm.loadConfig(id)
if err == nil {
pm.configs[id] = config
}
}
}
// loadConfig lädt eine Konfigurationsdatei
func (pm *ProviderManager) loadConfig(id string) (*ProviderConfig, error) {
filePath := filepath.Join(pm.configDir, id+".json")
data, err := os.ReadFile(filePath)
if err != nil {
return nil, err
}
var config ProviderConfig
if err := json.Unmarshal(data, &config); err != nil {
return nil, err
}
return &config, nil
}
// saveConfig speichert eine Konfiguration in eine Datei
func (pm *ProviderManager) saveConfig(id string, config *ProviderConfig) error {
// Stelle sicher, dass das Verzeichnis existiert
os.MkdirAll(pm.configDir, 0755)
filePath := filepath.Join(pm.configDir, id+".json")
data, err := json.MarshalIndent(config, "", " ")
if err != nil {
return err
}
return os.WriteFile(filePath, data, 0644)
}

22
backend/providers/types.go Normal file
View File

@@ -0,0 +1,22 @@
package providers
// SettingField beschreibt ein Konfigurationsfeld
type SettingField struct {
Name string `json:"name"`
Label string `json:"label"`
Type string `json:"type"` // text, password, number, email, url
Required bool `json:"required"`
Description string `json:"description"`
Default string `json:"default,omitempty"`
}
// ProviderInfo enthält Informationen über einen Provider
type ProviderInfo struct {
ID string `json:"id"`
Name string `json:"name"`
DisplayName string `json:"displayName"`
Description string `json:"description"`
Enabled bool `json:"enabled"`
Settings []SettingField `json:"settings"`
}