# WhitelistManager - Gestionnaire de Liste Blanche

## Vue d'ensemble

Le `WhitelistManager` est un composant de sécurité pour RPA Vision V2 qui gère la liste des fenêtres d'application autorisées pour l'automatisation. Il fournit un contrôle granulaire sur les applications où le système peut exécuter des actions automatisées.

## Fonctionnalités principales

### 1. Vérification de fenêtres autorisées
- Vérifie si une fenêtre est dans la liste blanche
- Support pour patterns avec wildcards (`*`)
- Correspondance insensible à la casse

### 2. Gestion de la liste blanche
- Ajout de fenêtres avec confirmation admin optionnelle
- Suppression de fenêtres
- Vidage complet de la liste
- Obtention de la liste complète

### 3. Persistance
- Sauvegarde automatique dans un fichier JSON
- Chargement au démarrage
- Export/Import pour partage de configurations

### 4. Métadonnées et audit
- Suivi de qui a ajouté chaque entrée
- Horodatage des modifications
- Confirmation admin enregistrée
- Statistiques sur la liste blanche

### 5. Journalisation
- Toutes les opérations sont loggées
- Événements de sécurité pour violations
- Intégration avec le système de logs chiffrés

## Utilisation

### Initialisation

```python
from core.whitelist_manager import WhitelistManager
from core.logger import Logger

# Créer un logger
logger = Logger()

# Créer le gestionnaire de liste blanche
whitelist_manager = WhitelistManager(
    logger=logger,
    require_admin_confirmation=True  # Nécessite confirmation pour ajouts
)
```

### Ajouter une fenêtre

```python
# Ajouter avec confirmation admin
success = whitelist_manager.add_to_whitelist(
    "Dolibarr*",
    admin_confirmed=True,
    added_by="admin_user"
)

# Sans confirmation (si require_admin_confirmation=False)
success = whitelist_manager.add_to_whitelist("Firefox*")
```

### Vérifier si une fenêtre est autorisée

```python
# Vérifier une fenêtre spécifique
if whitelist_manager.is_window_allowed("Dolibarr - Facturation"):
    print("Fenêtre autorisée")
else:
    print("Fenêtre bloquée")
```

### Patterns avec wildcards

Le WhitelistManager supporte plusieurs types de patterns:

```python
# Prefix wildcard - autorise toutes les fenêtres commençant par "Firefox"
whitelist_manager.add_to_whitelist("Firefox*", admin_confirmed=True)
# Autorise: "Firefox", "Firefox - Mozilla", "Firefox Developer Edition"

# Suffix wildcard - autorise toutes les fenêtres se terminant par "Chrome"
whitelist_manager.add_to_whitelist("*Chrome", admin_confirmed=True)
# Autorise: "Google Chrome", "Microsoft Edge Chrome"

# Wildcard au milieu - autorise les fenêtres avec pattern spécifique
whitelist_manager.add_to_whitelist("Fire*fox", admin_confirmed=True)
# Autorise: "Firefox", "Fire123fox", "Firefoxes"

# Correspondance exacte ou partielle
whitelist_manager.add_to_whitelist("Visual Studio Code", admin_confirmed=True)
# Autorise: "Visual Studio Code"
```

### Supprimer une fenêtre

```python
success = whitelist_manager.remove_from_whitelist("Firefox*")
```

### Obtenir la liste blanche

```python
whitelist = whitelist_manager.get_whitelist()
print(f"Liste blanche: {whitelist}")
```

### Obtenir des informations sur une entrée

```python
info = whitelist_manager.get_entry_info("Dolibarr*")
if info:
    print(f"Ajouté le: {info['added_at']}")
    print(f"Ajouté par: {info['added_by']}")
    print(f"Admin confirmé: {info['admin_confirmed']}")
```

### Statistiques

```python
stats = whitelist_manager.get_statistics()
print(f"Total entrées: {stats['total_entries']}")
print(f"Avec wildcards: {stats['entries_with_wildcards']}")
print(f"Exactes: {stats['entries_exact']}")
```

### Export/Import

```python
# Exporter la liste blanche
whitelist_manager.export_whitelist("whitelist_backup.json")

# Importer une liste blanche (remplace la liste actuelle)
whitelist_manager.import_whitelist("whitelist_backup.json")

# Importer en fusionnant avec la liste existante
whitelist_manager.import_whitelist(
    "whitelist_backup.json",
    merge=True,
    admin_confirmed=True
)
```

### Vider la liste blanche

```python
whitelist_manager.clear_whitelist()
```

## Intégration avec l'Orchestrateur

Le `WhitelistManager` est intégré dans l'`Orchestrator` pour vérifier automatiquement les fenêtres avant l'exécution d'actions:

```python
from core.orchestrator import Orchestrator
from core.whitelist_manager import WhitelistManager

# Créer le gestionnaire de liste blanche
whitelist_manager = WhitelistManager(logger=logger)

# Ajouter des fenêtres autorisées
whitelist_manager.add_to_whitelist("Dolibarr*", admin_confirmed=True)
whitelist_manager.add_to_whitelist("Firefox*", admin_confirmed=True)

# Créer l'orchestrateur avec le gestionnaire
orchestrator = Orchestrator(
    learning_manager=learning_manager,
    vision_utils=vision_utils,
    llm_manager=llm_manager,
    logger=logger,
    whitelist_manager=whitelist_manager
)

# L'orchestrateur vérifiera automatiquement la liste blanche
# avant d'exécuter des actions en mode Autopilot
```

L'orchestrateur fournit également des méthodes de convenance:

```python
# Ajouter via l'orchestrateur
orchestrator.add_to_whitelist("Visual Studio Code", admin_confirmed=True)

# Supprimer via l'orchestrateur
orchestrator.remove_from_whitelist("Visual Studio Code")

# Obtenir la liste blanche
whitelist = orchestrator.get_whitelist()

# Activer/désactiver l'application de la liste blanche
orchestrator.set_whitelist_enforcement(True)
```

## Format du fichier de liste blanche

Le fichier `whitelist.json` est stocké dans `data/user_profiles/` et a le format suivant:

```json
{
  "whitelist": [
    "Dolibarr*",
    "Firefox*",
    "Visual Studio Code"
  ],
  "metadata": {
    "created_at": "2025-11-13T14:52:07.468307",
    "last_modified": "2025-11-13T14:52:07.483380",
    "version": "1.0",
    "entries": {
      "Dolibarr*": {
        "added_at": "2025-11-13T14:52:07.468307",
        "added_by": "admin_user",
        "admin_confirmed": true
      },
      "Firefox*": {
        "added_at": "2025-11-13T14:52:07.470123",
        "added_by": "user",
        "admin_confirmed": true
      }
    }
  }
}
```

## Sécurité

### Permissions de fichier
Le fichier de liste blanche a des permissions restrictives (0600) pour empêcher les modifications non autorisées.

### Journalisation
Toutes les opérations sont loggées dans le système de logs chiffrés:
- Ajouts et suppressions d'entrées
- Vérifications de fenêtres
- Violations de liste blanche
- Modifications de configuration

### Confirmation admin
Lorsque `require_admin_confirmation=True`, les ajouts à la liste blanche nécessitent une confirmation explicite via le paramètre `admin_confirmed=True`.

## Exigences satisfaites

Le `WhitelistManager` satisfait les exigences suivantes du document de requirements:

- **Exigence 5.3**: Application de la liste blanche des fenêtres autorisées
- **Exigence 5.4**: Blocage et journalisation des violations de liste blanche

## Tests

Des tests complets sont disponibles dans:
- `geniusia2/core/whitelist_manager.py` (tests standalone)
- `test_whitelist_simple.py` (tests d'intégration)

Pour exécuter les tests:

```bash
# Tests standalone du module
python3 geniusia2/core/whitelist_manager.py

# Tests d'intégration complets
python3 test_whitelist_simple.py
```

## Exemple complet

```python
from core.whitelist_manager import WhitelistManager
from core.logger import Logger
from core.config import ensure_directories

# S'assurer que les répertoires existent
ensure_directories()

# Créer le gestionnaire
logger = Logger()
wm = WhitelistManager(logger=logger, require_admin_confirmation=True)

# Configurer la liste blanche
wm.add_to_whitelist("Dolibarr*", admin_confirmed=True, added_by="admin")
wm.add_to_whitelist("Firefox*", admin_confirmed=True, added_by="admin")
wm.add_to_whitelist("Visual Studio Code", admin_confirmed=True, added_by="admin")

# Vérifier des fenêtres
test_windows = [
    "Dolibarr - Facturation",
    "Firefox - Mozilla",
    "Visual Studio Code",
    "Unknown Application"
]

for window in test_windows:
    if wm.is_window_allowed(window):
        print(f"✓ Autorisé: {window}")
    else:
        print(f"✗ Bloqué: {window}")

# Afficher les statistiques
stats = wm.get_statistics()
print(f"\nStatistiques:")
print(f"  Total: {stats['total_entries']} entrées")
print(f"  Avec wildcards: {stats['entries_with_wildcards']}")
print(f"  Exactes: {stats['entries_exact']}")

# Exporter pour sauvegarde
wm.export_whitelist("whitelist_backup.json")
```

## Notes d'implémentation

- La correspondance de patterns est insensible à la casse
- Les wildcards (`*`) peuvent être utilisés au début, à la fin, ou au milieu d'un pattern
- Une liste blanche vide bloque toutes les fenêtres par défaut
- Les métadonnées sont automatiquement mises à jour à chaque modification
- Le fichier est sauvegardé automatiquement après chaque modification
