---

## 🖥️ Interface de gestion de l'interface utilisateur

BlockGuard inclut une **application de bureau WPF** pour gérer les fichiers et dossiers protégés via une interface visuelle — pas besoin de modifier `appsettings.json` manuellement.

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

### Fonctionnalités

- **Tableau de bord** — Aperçu de l'état de protection (nombre total de fichiers, dossiers, état du chiffrement)
- **Fichiers protégés** — Ajouter/supprimer des fichiers et dossiers à protéger de l'accès IA via des boîtes de dialogue de navigation
- **Journal d'activité** — Journal en temps réel de toutes les modifications de configuration
- **Paramètres** — Afficher le chemin du fichier de configuration et les informations sur l'agent
- **État de l'agent** — Indicateur en direct indiquant si le service agent BlockGuard est en cours d'exécution

### Comment lancer l'interface utilisateur```powershell
# From the project root
dotnet run --project src/BlockGuard.UI

---

## 🚀 Démarrage rapide

### 1. Cloner le dépôt```powershell
git clone [email protected]:m2l33k/BlockGuard.git
cd BlockGuard

### 3. Construire la solution```powershell
dotnet build BlockGuard.sln --configuration Release

### 4. Configurer les chemins protégés et les règles

Modifiez `src/BlockGuard.Agent/appsettings.json` pour définir **quels fichiers protéger** et **quels processus sont autorisés** :```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
      }
    ]
  }
}

---

## ⚙️ Configuration

Toute la configuration se trouve dans `src/BlockGuard.Agent/appsettings.json` sous la section `"BlockGuard"`.

### Chemins protégés

Un tableau de fichiers ou répertoires à protéger. Les répertoires protègent tous les fichiers récursivement.```json
"ProtectedPaths": [
  "C:\\Secrets\\ai-model-keys",
  "C:\\Secrets\\api-credentials.json",
  "D:\\Confidential\\reports"
]

**Exemple : Règle basée sur la signature (pour tout outil de gestion signé)**```json
{
  "RuleName": "Signed-Management-Tool",
  "ExecutablePath": null,
  "ExpectedFileHash": null,
  "ExpectedSignerSubject": "CN=Contoso Security",
  "MinimumIntegrityLevel": "High",
  "RequireSignature": true
}

### Autres options

| Option | Valeur par défaut | Description |
|---|---|---|
| `IdentityCacheTtlSeconds` | `30` | Durée (en secondes) pendant laquelle une identité de processus validée reste en cache |
| `HandleTimeoutSeconds` | `60` | Durée maximale (en secondes) d'une concession ACL temporaire |
| `AuditLogPath` | `C:\ProgramData\BlockGuard\Logs\audit.json` | Chemin du fichier journal d'audit JSON |
| `EnableDpapiEncryption` | `true` | Chiffrer les fichiers protégés au repos avec DPAPI |
| `DpapiScope` | `LocalMachine` | Étendue DPAPI : `LocalMachine` ou `CurrentUser` |

---

## 🏃 Exécution de l'agent

### Option A : Mode développement (Console)

Idéal pour les tests et le débogage. Exécutez à partir d'un **PowerShell élevé (Administrateur)** :```powershell
dotnet run --project src/BlockGuard.Agent --configuration Release

Appuyez sur `Ctrl+C` pour arrêter.

### Option B: Installer en tant que service Windows (Production)```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

## ✅ Vérification du fonctionnement

Suivez ces étapes pour confirmer que BlockGuard protège correctement les fichiers.

### Test 1 : Vérification de la construction```powershell
# From the project root directory
dotnet build BlockGuard.sln

# Expected: Build succeeded with 0 Error(s)

**✅ Résultat attendu :**
- Message `BlockGuard Security Agent Starting`
- Aucune erreur `CRITICAL` ou `FATAL`
- `ETW file trace session started successfully`
- `BlockGuard is now actively protecting X path(s)`

**❌ Si vous voyez `ETW session — insufficient privileges` :**
- Vous n'exécutez pas PowerShell en tant qu'Administrateur. Cliquez droit sur PowerShell → "Exécuter en tant qu'administrateur"

### Test 3 : Vérification du verrouillage ACL

Après le démarrage de l'agent, vérifiez que les fichiers protégés sont verrouillés :```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: Inspection du journal d'audit

Après que l'agent s'est exécuté pendant un certain temps, vérifiez le journal d'audit :```powershell
# View the last 10 audit entries
Get-Content "C:\ProgramData\BlockGuard\Logs\audit.json" | Select-Object -Last 10

# Test 6 : Vérifier la capture d'événements ETW

Ouvrez un second terminal et tentez d'accéder à un fichier protégé pendant que l'agent est en cours d'exécution :```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 : Vérifier que l'accès non autorisé est bloqué (modèle IA)

Lorsqu'un processus (comme un modèle IA non autorisé) tente de lire un dossier ou un fichier protégé, l'agent refuse immédiatement l'accès. L'IA recevra une erreur stricte **Accès refusé** et la tentative est enregistrée :

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

### Test 8 : Vérifier le chiffrement DPAPI```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: Vérifier le répertoire des logs```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)

## 🔬 Comment ça marche

### Séquence de démarrage (5 phases)```
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

### Validation de processus (6 vérifications)

Lorsqu'un processus accède à un fichier protégé, BlockGuard le valide via :

1. **Chemin de l'exécutable** — Résout et canonicalise le chemin complet (empêche le path traversal)
2. **Hash SHA-256** — Calcule le hash du binaire sur le disque (détecte le remplacement de fichier)
3. **Signature Authenticode** — Valide la chaîne de signature numérique (détecte les binaires non signés / modifiés)
4. **SID du propriétaire du processus** — Interroge le jeton pour identifier le compte exécutant
5. **Niveau d'intégrité** — Lit l'étiquette obligatoire (Untrusted/Low/Medium/High/System)
6. **ID du processus parent** — Trace la chaîne de création de processus (détecte l'injection)

Toutes les vérifications sont **fail-closed** : si une étape de validation échoue, l'accès est **REFUSÉ**.

---

## 🛠️ Dépannage

### "Session ETW — privilèges insuffisants"

**Cause:** L'agent ne s'exécute pas avec les privilèges Administrateur/SYSTEM.

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

### Erreurs de build après le clonage

**Correctif :** Restaurer les packages NuGet :```powershell
dotnet restore BlockGuard.sln
dotnet build BlockGuard.sln

---

## 🔒 Considérations de sécurité

### Ce que cet agent peut faire
- ✅ Empêcher les processus non autorisés de **lire** les fichiers protégés via l'application des ACL
- ✅ Détecter et **auditer** toutes les tentatives d'accès aux fichiers en temps réel via ETW
- ✅ Chiffrer les fichiers **au repos** à l'aide de DPAPI
- ✅ Détecter et **corriger automatiquement** les falsifications d'ACL

### Ce que cet agent ne peut pas faire
- ❌ **Bloquer les lectures de fichiers en transit** — Il s'agit d'un agent en mode utilisateur ; un véritable blocage en transit nécessite un pilote minifiltre noyau
- ❌ **Arrêter les attaques au niveau du noyau** — Un pilote noyau malveillant peut contourner les ACL NTFS
- ❌ **Empêcher les administrateurs de passer outre** — Les comptes administrateur peuvent supprimer les ACL (atténué par la détection de falsification)

### Recommandations pour la production

1. **Exécuter en tant que `NT AUTHORITY\SYSTEM`** — Utilisez un service Windows, pas une application console
2. **Signer le binaire de l'agent** avec un certificat Authenticode pour empêcher l'auto-falsification
3. **Activer BitLocker** sur le volume pour le chiffrement complet du disque (complète DPAPI)
4. **Transférer les journaux d'audit vers un SIEM** pour une surveillance centralisée
5. **Activer Secure Boot + Driver Signature Enforcement** pour empêcher le contournement au niveau du noyau

---

## 🤝 Contribution

1. Forkez le dépôt
2. Créez une branche de fonctionnalité : `git checkout -b feature/my-feature`
3. Commitez vos modifications : `git commit -m "Add my feature"`
4. Poussez vers la branche : `git push origin feature/my-feature`
5. Ouvrez une Pull Request

### Style de code
- Suivez les conventions de nommage C# (PascalCase pour les membres publics)
- Ajoutez des commentaires de documentation XML à toutes les API publiques
- Chaque validation doit **échouer en mode fermé** (refuser en cas d'erreur)
- Disposez explicitement tous les handles natifs dans les blocs `finally`
- Mettez à zéro les tampons mémoire sensibles après utilisation

---

## 📄 Licence

Ce projet est sous licence MIT. Voir [LICENSE](https://github.com/m2l33k/blockguard/blob/HEAD/LICENSE) pour plus de détails.

---

<p align="center">
  <b>Conçu avec des principes de sécurité avant tout pour la protection des fichiers Windows.</b>
  <br/>
  <sub>BlockGuard — parce que vos données méritent un gardien, pas seulement un verrou.</sub>
</p>