---

## 🖥️ Benutzeroberfläche zur Verwaltung

BlockGuard enthält eine **WPF-Desktopanwendung** zur Verwaltung geschützter Dateien und Ordner über eine visuelle Oberfläche — ohne dass `appsettings.json` manuell bearbeitet werden muss.

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/12349/51a9b7894117382666d869cee59860a33698f666133bd23c6b6cd48b225d942c.png" alt="BlockGuard UI" width="640" />
</p>

### Funktionen

- **Dashboard** — Übersicht über den Schutzstatus (Gesamtanzahl Dateien, Ordner, Verschlüsselungszustand)
- **Geschützte Dateien** — Hinzufügen/Entfernen von Dateien und Ordnern, die vor KI-Zugriff geschützt werden sollen, über Dateibrowser-Dialoge
- **Aktivitätsprotokoll** — Echtzeitprotokoll aller Konfigurationsänderungen
- **Einstellungen** — Anzeigen des Konfigurationsdateipfads und der Agenteninformationen
- **Agentenstatus** — Live-Anzeige, ob der BlockGuard-Agentendienst ausgeführt wird

### So starten Sie die Benutzeroberfläche```powershell
# From the project root
dotnet run --project src/BlockGuard.UI

---

## 🚀 Schnellstart

### 1. Repository klonen```powershell
git clone [email protected]:m2l33k/BlockGuard.git
cd BlockGuard

### 3. Lösung erstellen```powershell
dotnet build BlockGuard.sln --configuration Release

### 4. Konfigurieren der geschützten Pfade und Regeln

Bearbeiten Sie `src/BlockGuard.Agent/appsettings.json`, um **welche Dateien geschützt werden sollen** und **welche Prozesse autorisiert sind** zu definieren:```json
{
  "BlockGuard": {
    "ProtectedPaths": [
      "C:\\Secrets\\ai-model-keys",
      "C:\\Secrets\\api-credentials.json"
    ],
    "AuthorizedProcesses": [
      {
        "RuleName": "AI-Model-Inference-Engine",
        "ExecutablePath": "C:\\Program Files\\MyAI\\inference.exe",
        "MinimumIntegrityLevel": "Medium",
        "RequireSignature": false
      }
    ]
  }
}

---

## ⚙️ Konfiguration

Die gesamte Konfiguration befindet sich in `src/BlockGuard.Agent/appsettings.json` im Abschnitt `"BlockGuard"`.

### Geschützte Pfade

Ein Array von Dateien oder Verzeichnissen, die geschützt werden sollen. Verzeichnisse schützen alle darin enthaltenen Dateien rekursiv.```json
"ProtectedPaths": [
  "C:\\Secrets\\ai-model-keys",
  "C:\\Secrets\\api-credentials.json",
  "D:\\Confidential\\reports"
]

**Beispiel: Signaturbasierte Regel (für jedes signierte Verwaltungstool)**```json
{
  "RuleName": "Signed-Management-Tool",
  "ExecutablePath": null,
  "ExpectedFileHash": null,
  "ExpectedSignerSubject": "CN=Contoso Security",
  "MinimumIntegrityLevel": "High",
  "RequireSignature": true
}

### Weitere Optionen

| Option | Standard | Beschreibung |
|---|---|---|
| `IdentityCacheTtlSeconds` | `30` | Wie lange (Sekunden) eine validierte Prozessidentität im Cache bleibt |
| `HandleTimeoutSeconds` | `60` | Maximale Dauer (Sekunden) einer temporären ACL-Erteilung |
| `AuditLogPath` | `C:\ProgramData\BlockGuard\Logs\audit.json` | Pfad für die JSON-Überwachungsprotokolldatei |
| `EnableDpapiEncryption` | `true` | Verschlüsseln geschützter Dateien im Ruhezustand mit DPAPI |
| `DpapiScope` | `LocalMachine` | DPAPI-Bereich: `LocalMachine` oder `CurrentUser` |

---

## 🏃 Ausführen des Agents

### Option A: Entwicklungsmodus (Konsole)

Am besten zum Testen und Debuggen. Führen Sie von einer **erhöhten (Administrator-)PowerShell** aus:```powershell
dotnet run --project src/BlockGuard.Agent --configuration Release

Drücken Sie `Ctrl+C` zum Beenden.

### Option B: Als Windows-Dienst installieren (Produktion)```powershell
# 1. Publish a self-contained build
dotnet publish src/BlockGuard.Agent -c Release -r win-x64 --self-contained -o C:\BlockGuard

# 2. Create the Windows Service
sc.exe create BlockGuard binPath= "C:\BlockGuard\BlockGuard.Agent.exe" start= auto obj= "NT AUTHORITY\SYSTEM" DisplayName= "BlockGuard Security Agent"

# 3. Set the service description
sc.exe description BlockGuard "Process-based file access security agent (DLP)"

# 4. Start the service
sc.exe start BlockGuard

---

## ✅ Überprüfen der Funktionsweise

Befolgen Sie diese Schritte, um zu bestätigen, dass BlockGuard Dateien korrekt schützt.

### Test 1: Build-Überprüfung```powershell
# From the project root directory
dotnet build BlockGuard.sln

# Expected: Build succeeded with 0 Error(s)

**✅ Erwartete Ausgabe:**
- Meldung `BlockGuard Security Agent Starting`
- Keine `CRITICAL`- oder `FATAL`-Fehler
- `ETW file trace session started successfully`
- `BlockGuard is now actively protecting X path(s)`

**❌ Falls Sie `ETW session — insufficient privileges` sehen:**
- Sie führen PowerShell NICHT als Administrator aus. Rechtsklick auf PowerShell → "Als Administrator ausführen"

### Test 3: ACL-Sperre überprüfen

Starten Sie den Agenten und überprüfen Sie, ob geschützte Dateien gesperrt sind:```powershell
# Create a test protected file
New-Item -Path "C:\Secrets" -ItemType Directory -Force
Set-Content -Path "C:\Secrets\api-credentials.json" -Value '{"api_key": "secret123"}'

# Start the agent (it will lock down the file)
dotnet run --project src/BlockGuard.Agent

# In ANOTHER non-admin terminal, try to read the file:
Get-Content "C:\Secrets\api-credentials.json"
# Expected: Access Denied error

### Test 5: Prüfung des Audit-Logs

Nachdem der Agent eine Weile gelaufen ist, überprüfen Sie das Audit-Log:```powershell
# View the last 10 audit entries
Get-Content "C:\ProgramData\BlockGuard\Logs\audit.json" | Select-Object -Last 10

### Test 6: ETW-Ereigniserfassung verifizieren

Öffnen Sie ein zweites Terminal und versuchen Sie, auf eine geschützte Datei zuzugreifen, während der Agent läuft:```powershell
# Terminal 1: Agent is running with console output
dotnet run --project src/BlockGuard.Agent

# Terminal 2: Try reading a protected file with notepad
notepad.exe "C:\Secrets\api-credentials.json"

### Test 7: Überprüfen, dass unbefugter Zugriff blockiert wird (KI-Modell)

Wenn ein Prozess (wie ein unbefugtes KI-Modell) versucht, einen geschützten Ordner oder eine geschützte Datei zu lesen, verweigert der Agent sofort den Zugriff. Das KI-Modell erhält einen strikten **Zugriff verweigert**-Fehler, und der Versuch wird protokolliert:

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/12349/d2a2e20c0fc60e8b3a5f614b0a53c6c7275b634e93b1ce0b9fe4440c38215fac.png" alt="Unauthorized Access Denied" width="600" />
</p>

### Test 8: Überprüfen der DPAPI-Verschlüsselung```powershell
# Check that the .enc file was created
Test-Path "C:\Secrets\api-credentials.json.enc"
# Expected: True

# Check that the original plaintext file was securely deleted
Test-Path "C:\Secrets\api-credentials.json"
# Expected: False (if EnableDpapiEncryption is true)

### Test 10: Logs-Verzeichnis überprüfen```powershell
# Check both log locations
Get-ChildItem "C:\ProgramData\BlockGuard\Logs\"

# Expected files:
# audit.json              (structured JSON audit log)
# blockguard-20260305.log (daily rolling application log)

---

## 🔬 Wie es funktioniert

### Startsequenz (5 Phasen)```
Phase 1: ACL Lockdown
  └─ Strip all permissions from protected files
  └─ Grant access only to SYSTEM + Administrators
  └─ Disable ACL inheritance

Phase 2: DPAPI Encryption (optional)
  └─ Encrypt each protected file at rest
  └─ Securely delete plaintext (overwrite with random data)
  └─ Store ciphertext as .enc files

Phase 3: Event Subscription
  └─ Register handler for file access events

Phase 4: ETW Monitoring
  └─ Start kernel-level file trace session
  └─ Filter events by protected paths
  └─ Emit FileAccessEvent for each match

Phase 5: Integrity Check Loop
  └─ Every 60 seconds, verify ACLs are intact
  └─ Auto-remediate if tampering detected

### Prozessvalidierung (6 Prüfungen)

Wenn ein Prozess auf eine geschützte Datei zugreift, validiert BlockGuard diesen durch:

1. **Executable Path** — Löst den vollständigen Pfad auf und kanonisiert ihn (verhindert Path Traversal)
2. **SHA-256 Hash** — Berechnet den Hash der Binärdatei auf der Festplatte (erkennt Dateiaustausch)
3. **Authenticode Signature** — Validiert die digitale Signaturkette (erkennt unsignierte/manipulierte Binärdateien)
4. **Process Owner SID** — Fragt das Token ab, um das ausgeführte Konto zu identifizieren
5. **Integrity Level** — Liest das obligatorische Label (Untrusted/Low/Medium/High/System)
6. **Parent Process ID** — Verfolgt die Prozesserstellungskette (erkennt Injection)

Alle Prüfungen sind **fail-closed**: falls ein Validierungsschritt fehlschlägt, wird der Zugriff **VERWEIGERT**.

---

## 🛠️ Fehlerbehebung

### "ETW session – unzureichende Berechtigungen"

**Ursache:** Der Agent läuft nicht mit Administrator/SYSTEM-Berechtigungen.

**Behebung:**```powershell
# Right-click PowerShell → "Run as Administrator"
dotnet run --project src/BlockGuard.Agent

### Build-Fehler nach dem Klonen

**Behebung:** NuGet-Pakete wiederherstellen:```powershell
dotnet restore BlockGuard.sln
dotnet build BlockGuard.sln

---

## 🔒 Sicherheitsüberlegungen

### Was dieser Agent tun kann
- ✅ Verhindern, dass nicht autorisierte Prozesse geschützte Dateien **lesen** – durch ACL-Durchsetzung
- ✅ Erkennen und **protokollieren** aller Dateizugriffsversuche in Echtzeit über ETW
- ✅ Verschlüsseln von Dateien **im Ruhezustand** mittels DPAPI
- ✅ Erkennen und **automatische Behebung** von ACL-Manipulationen

### Was dieser Agent nicht tun kann
- ❌ **Dateilesevorgänge blockieren** — Dies ist ein User-Mode-Agent; echte Blockierung während des Vorgangs erfordert einen Kernel-Minifilter-Treiber
- ❌ **Kernel-Level-Angriffe stoppen** — Ein böswilliger Kernel-Treiber kann NTFS-ACLs umgehen
- ❌ **Administratoren am Überschreiben hindern** — Admin-Konten können ACLs entfernen (durch Manipulationserkennung gemildert)

### Empfehlungen für die Produktion

1. **Als `NT AUTHORITY\SYSTEM` ausführen** — Verwenden Sie einen Windows-Dienst, keine Konsolenanwendung
2. **Signieren Sie die Agent-Binärdatei** mit einem Authenticode-Zertifikat, um Selbstmanipulation zu verhindern
3. **Aktivieren Sie BitLocker** auf dem Volume für die Vollverschlüsselung (ergänzt DPAPI)
4. **Leiten Sie Audit-Protokolle an ein SIEM weiter** für die zentrale Überwachung
5. **Aktivieren Sie Secure Boot + Treibersignaturerzwingung**, um Kernel-Level-Umgehungen zu verhindern

---

## 🤝 Mitwirken

1. Repository forken
2. Erstellen Sie einen Feature-Branch: `git checkout -b feature/my-feature`
3. Comitten Sie Ihre Änderungen: `git commit -m "Add my feature"`
4. Pushen Sie den Branch: `git push origin feature/my-feature`
5. Öffnen Sie einen Pull Request

### Code-Stil
- Befolgen Sie die C#-Namenskonventionen (PascalCase für öffentliche Member)
- Fügen Sie allen öffentlichen APIs XML-Dokumentationskommentare hinzu
- Jede Validierung muss **fail-closed** sein (bei Fehler verweigern)
- Entsorgen Sie alle nativen Handles explizit in `finally`-Blöcken
- Löschen Sie vertrauliche Speicherpuffer nach der Verwendung

---

## 📄 Lizenz

Dieses Projekt ist unter der MIT-Lizenz lizenziert. Weitere Details finden Sie in der [LIZENZ](https://github.com/m2l33k/blockguard/blob/main/LICENSE).

---

<p align="center">
  <b>Erstellt mit Sicherheit-im-Vordergrund-Prinzipien für den Windows-Dateischutz.</b>
  <br/>
  <sub>BlockGuard – denn Ihre Daten verdienen eine Wache, nicht nur ein Schloss.</sub>
</p>