IntelSight/Hetzner-Backup
3
0
Fork 0
Code Issues Pull-Requests Actions Pakete Projekte Releases Wiki Aktivität

Alle .md einmal aufgeräumt

Quellcode durchsuchen
Dieser Commit ist enthalten in:
UserIsMH
2025-06-19 17:52:21 +02:00
Ursprung f73c64aa9e
Commit 0e79e5ed57
12 geänderte Dateien mit 1006 neuen und 2160 gelöschten Zeilen
Patch-Datei herunterladen Vergleichs-Datei herunterladen Alle Dateien ausklappen Alle Dateien einklappen

335
v2_lizenzserver/LIZENZSERVER_ANLEITUNG.md
Datei anzeigen

@@ -1,335 +0,0 @@
# Lizenzserver Nutzungsanleitung
## Übersicht
Der Lizenzserver läuft unter: `https://api-software-undso.z5m7q9dk3ah2v1plx6ju.com`
## API Endpoints
### 1. Lizenz aktivieren
**POST** `/api/license/activate`
Aktiviert eine Lizenz für eine bestimmte Maschine.
```json
{
"license_key": "XXXX-XXXX-XXXX-XXXX",
"machine_id": "UNIQUE-MACHINE-ID",
"hardware_hash": "SHA256-HARDWARE-FINGERPRINT",
"os_info": {
"os": "Windows",
"version": "10.0.19041"
},
"app_version": "1.0.0"
}
```
**Antwort bei Erfolg:**
```json
{
"success": true,
"message": "License activated successfully",
"activation_id": 123,
"expires_at": "2025-12-31T23:59:59",
"features": {
"all_features": true
}
}
```
### 2. Lizenz verifizieren (Heartbeat)
**POST** `/api/license/verify`
Sollte alle 15 Minuten aufgerufen werden.
```json
{
"license_key": "XXXX-XXXX-XXXX-XXXX",
"machine_id": "UNIQUE-MACHINE-ID",
"hardware_hash": "SHA256-HARDWARE-FINGERPRINT",
"activation_id": 123
}
```
**Antwort:**
```json
{
"valid": true,
"message": "License is valid",
"expires_at": "2025-12-31T23:59:59",
"features": {
"all_features": true
},
"requires_update": false,
"update_url": null
}
```
### 3. Version prüfen
**POST** `/api/version/check`
```json
{
"current_version": "1.0.0",
"license_key": "XXXX-XXXX-XXXX-XXXX"
}
```
**Antwort:**
```json
{
"latest_version": "1.1.0",
"current_version": "1.0.0",
"update_available": true,
"is_mandatory": false,
"download_url": "https://download.example.com/v1.1.0",
"release_notes": "Bug fixes and improvements"
}
```
### 4. Lizenzinfo abrufen
**GET** `/api/license/info/{license_key}`
Liefert detaillierte Informationen über eine Lizenz.
## Authentifizierung
Alle API-Anfragen benötigen einen API-Key im Authorization Header:
```
Authorization: Bearer YOUR-API-KEY-HERE
```
## Client-Integration Beispiel (Python)
```python
import requests
import hashlib
import platform
import uuid
import json
from datetime import datetime, timedelta
class LicenseClient:
def __init__(self, api_key, server_url="https://api-software-undso.z5m7q9dk3ah2v1plx6ju.com"):
self.api_key = api_key
self.server_url = server_url
self.headers = {"Authorization": f"Bearer {api_key}"}
def get_machine_id(self):
"""Eindeutige Maschinen-ID generieren"""
return str(uuid.getnode()) # MAC-Adresse
def get_hardware_hash(self):
"""Hardware-Fingerprint erstellen"""
machine_id = self.get_machine_id()
cpu_info = platform.processor()
system_info = f"{platform.system()}-{platform.machine()}"
combined = f"{machine_id}-{cpu_info}-{system_info}"
return hashlib.sha256(combined.encode()).hexdigest()
def activate_license(self, license_key):
"""Lizenz aktivieren"""
data = {
"license_key": license_key,
"machine_id": self.get_machine_id(),
"hardware_hash": self.get_hardware_hash(),
"os_info": {
"os": platform.system(),
"version": platform.version(),
"machine": platform.machine()
},
"app_version": "1.0.0"
}
response = requests.post(
f"{self.server_url}/api/license/activate",
headers=self.headers,
json=data,
verify=True # SSL-Zertifikat prüfen
)
return response.json()
def verify_license(self, license_key, activation_id):
"""Lizenz verifizieren (Heartbeat)"""
data = {
"license_key": license_key,
"machine_id": self.get_machine_id(),
"hardware_hash": self.get_hardware_hash(),
"activation_id": activation_id
}
response = requests.post(
f"{self.server_url}/api/license/verify",
headers=self.headers,
json=data,
verify=True
)
return response.json()
def check_version(self, license_key, current_version):
"""Version prüfen"""
data = {
"current_version": current_version,
"license_key": license_key
}
response = requests.post(
f"{self.server_url}/api/version/check",
headers=self.headers,
json=data,
verify=True
)
return response.json()
# Verwendungsbeispiel
if __name__ == "__main__":
client = LicenseClient("YOUR-API-KEY")
# Lizenz aktivieren
result = client.activate_license("USER-LICENSE-KEY")
if result["success"]:
activation_id = result["activation_id"]
print(f"Lizenz aktiviert! Activation ID: {activation_id}")
# Lizenz verifizieren
verify_result = client.verify_license("USER-LICENSE-KEY", activation_id)
if verify_result["valid"]:
print("Lizenz ist gültig!")
```
## Client-Integration Beispiel (C#)
```csharp
using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using System.Security.Cryptography;
using System.Management;
public class LicenseClient
{
private readonly HttpClient httpClient;
private readonly string apiKey;
private readonly string serverUrl;
public LicenseClient(string apiKey, string serverUrl = "https://api-software-undso.z5m7q9dk3ah2v1plx6ju.com")
{
this.apiKey = apiKey;
this.serverUrl = serverUrl;
httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {apiKey}");
}
private string GetMachineId()
{
// CPU ID abrufen
string cpuId = "";
ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT ProcessorId FROM Win32_Processor");
foreach (ManagementObject obj in searcher.Get())
{
cpuId = obj["ProcessorId"].ToString();
break;
}
return cpuId;
}
private string GetHardwareHash()
{
string machineId = GetMachineId();
string systemInfo = Environment.MachineName + Environment.OSVersion;
using (SHA256 sha256 = SHA256.Create())
{
byte[] hashBytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(machineId + systemInfo));
return BitConverter.ToString(hashBytes).Replace("-", "").ToLowerInvariant();
}
}
public async Task<LicenseActivationResponse> ActivateLicenseAsync(string licenseKey)
{
var requestData = new
{
license_key = licenseKey,
machine_id = GetMachineId(),
hardware_hash = GetHardwareHash(),
os_info = new
{
os = "Windows",
version = Environment.OSVersion.Version.ToString()
},
app_version = "1.0.0"
};
var json = JsonSerializer.Serialize(requestData);
var content = new StringContent(json, Encoding.UTF8, "application/json");
var response = await httpClient.PostAsync($"{serverUrl}/api/license/activate", content);
var responseContent = await response.Content.ReadAsStringAsync();
return JsonSerializer.Deserialize<LicenseActivationResponse>(responseContent);
}
}
public class LicenseActivationResponse
{
public bool success { get; set; }
public string message { get; set; }
public int? activation_id { get; set; }
public DateTime? expires_at { get; set; }
}
```
## Wichtige Hinweise
### Sicherheit
- API-Keys niemals im Quellcode hartcodieren
- SSL-Zertifikat immer prüfen (verify=True)
- Hardware-Hash lokal zwischenspeichern
### Rate Limiting
- Max. 100 Anfragen pro Minute pro API-Key
- Heartbeat alle 15 Minuten (nicht öfter)
### Offline-Betrieb
- 7 Tage Grace Period bei Verbindungsproblemen
- Letzte gültige Lizenz lokal cachen
- Bei Hardware-Änderung: Grace Period nutzen
### Fehlerbehandlung
```python
try:
result = client.verify_license(license_key, activation_id)
except requests.exceptions.ConnectionError:
# Offline-Modus: Gecachte Lizenz prüfen
if cached_license_valid():
continue_execution()
else:
show_error("Keine Internetverbindung und Lizenz abgelaufen")
except requests.exceptions.HTTPError as e:
if e.response.status_code == 401:
show_error("Ungültiger API-Key")
elif e.response.status_code == 403:
show_error("Lizenz ungültig oder abgelaufen")
```
## Test-Zugangsdaten
Für Entwicklungszwecke:
- Test API-Key: `test-api-key-12345`
- Test Lizenz: `TEST-LICENSE-KEY-12345`
**WICHTIG:** Für Produktion eigene API-Keys und Lizenzen erstellen!
## Support
Bei Problemen:
1. Logs prüfen: `docker logs license-server`
2. API-Status: https://api-software-undso.z5m7q9dk3ah2v1plx6ju.com/health
3. Datenbank prüfen: Lizenzen und Aktivierungen

29
v2_lizenzserver/README.md
Datei anzeigen

@@ -1,29 +0,0 @@
# License Server für v2-Docker
Dieser License Server ersetzt den Dummy-Container und bietet vollständige Lizenzmanagement-Funktionalität.
## Features
- Lizenzaktivierung mit Hardware-Binding
- Heartbeat/Verifizierung alle 15 Minuten
- Versionskontrolle mit Update-Erzwingung
- Offline Grace Period (7 Tage)
- Multi-Aktivierung Support
## API Endpoints
- POST `/api/license/activate` - Lizenz aktivieren
- POST `/api/license/verify` - Lizenz verifizieren (Heartbeat)
- POST `/api/version/check` - Version prüfen
- GET `/api/license/info/{license_key}` - Lizenzinfo abrufen
## Deployment
Der Server läuft im v2-Docker Stack und ist über nginx erreichbar:
- Extern: https://api-software-undso.z5m7q9dk3ah2v1plx6ju.com
- Intern: http://license-server:8443
## Konfiguration
Die Konfiguration erfolgt über die `.env` Datei:
- `DATABASE_URL` - Verbindung zur PostgreSQL Datenbank
- `SECRET_KEY` - JWT Secret Key für Token-Signierung
## Integration
Siehe `LIZENZSERVER_ANLEITUNG.md` und die Beispiele in `client_examples/` für die Client-Integration.

90
v2_lizenzserver/TODO.md
Datei anzeigen

@@ -1,90 +0,0 @@
# TODO - License Server & Admin Panel Erweiterungen
## 🎯 Phase 1: Admin Panel Integration (Priorität: Hoch)
### Neue Lizenz-Verwaltung im Admin Panel
- [ ] Neuer Menüpunkt "Lizenzen" im Admin Panel
- [ ] Dashboard mit Lizenz-Statistiken
- [ ] Anzahl aktive/abgelaufene Lizenzen
- [ ] Aktivierungen pro Lizenz
- [ ] Grafische Auswertungen
- [ ] Lizenz-Erstellung Formular
- [ ] Lizenzschlüssel generieren
- [ ] Ablaufdatum festlegen
- [ ] Max. Aktivierungen definieren
- [ ] Kundeninformationen speichern
- [ ] Lizenz-Übersicht Tabelle
- [ ] Suche/Filter-Funktionen
- [ ] Status anzeigen (aktiv/abgelaufen/gesperrt)
- [ ] Aktivierungen einsehen
- [ ] Lizenzen deaktivieren/reaktivieren
- [ ] API-Key Verwaltung
- [ ] Neue API-Keys generieren
- [ ] Bestehende Keys anzeigen/deaktivieren
- [ ] Berechtigungen festlegen
## 🔒 Phase 2: Sicherheits-Optimierungen (Priorität: Mittel)
### Rate Limiting in Nginx
- [ ] API Rate Limiting implementieren (10 Requests/Minute)
- [ ] Burst-Handling konfigurieren
- [ ] IP-basierte Limits für API-Endpoints
### Datenbank-Sicherheit
- [ ] Separaten Read-Only DB-User für API erstellen
- [ ] Admin-User mit eingeschränkten Rechten
- [ ] Connection Pooling optimieren
### GeoIP-Blocking
- [ ] GeoIP-Modul in Nginx installieren
- [ ] Länder-Blacklist konfigurieren
- [ ] VPN-Erkennung implementieren
- [ ] Logging verdächtiger Zugriffe
## 📊 Phase 3: Monitoring & Backup (Priorität: Mittel)
### Monitoring-System
- [ ] Prometheus einrichten
- [ ] Grafana Dashboards erstellen
- [ ] API-Zugriffe
- [ ] Lizenz-Aktivierungen
- [ ] System-Ressourcen
- [ ] Alerting bei Anomalien
- [ ] Zu viele fehlgeschlagene Aktivierungen
- [ ] Verdächtige Zugriffsmuster
- [ ] System-Ausfälle
### Backup-Strategie
- [ ] Automatische tägliche DB-Backups
- [ ] Backup-Rotation (30 Tage aufbewahren)
- [ ] Verschlüsselung der Backups
- [ ] Offsite-Backup zu Cloud-Storage
- [ ] Restore-Tests durchführen
## 🚀 Phase 4: Performance & Features (Priorität: Niedrig)
### Performance-Optimierungen
- [ ] Redis Cache für häufige Queries
- [ ] Database Indexing optimieren
- [ ] API Response Caching
### Erweiterte Features
- [ ] Export-Funktionen (CSV/Excel)
- [ ] Email-Benachrichtigungen
- [ ] Bei Lizenz-Ablauf
- [ ] Bei verdächtigen Aktivitäten
- [ ] Lizenz-Templates für häufige Konfigurationen
- [ ] Bulk-Operationen (mehrere Lizenzen gleichzeitig)
## 📝 Dokumentation
- [ ] API-Dokumentation erweitern
- [ ] Admin Panel Benutzerhandbuch
- [ ] Deployment-Guide aktualisieren
- [ ] Troubleshooting-Guide erstellen
## Prioritäten:
1. **Sofort**: Phase 1 - Admin Panel Integration
2. **Nächste Woche**: Phase 2 - Sicherheits-Optimierungen
3. **Nächster Monat**: Phase 3 - Monitoring & Backup
4. **Bei Bedarf**: Phase 4 - Performance & Features