4NK_vault/docs/security-model.md

# Modèle de sécurité - 4NK Vault

## Vue d'ensemble

Le modèle de sécurité du projet 4NK Vault repose sur plusieurs couches de protection pour assurer la confidentialité, l'intégrité et la disponibilité des données de configuration.

## Architecture de sécurité

```
┌─────────────────────────────────────────────────────────────┐
│                    Couche de sécurité                       │
├─────────────────────────────────────────────────────────────┤
│  Application Layer    │ HTTPS + Certificats SSL             │
├─────────────────────────────────────────────────────────────┤
│  Transport Layer      │ TLS 1.2+ avec ciphers modernes     │
├─────────────────────────────────────────────────────────────┤
│  Encryption Layer     │ ChaCha20-Poly1305 (quantique)       │
├─────────────────────────────────────────────────────────────┤
│  Access Control       │ Validation des chemins + .env       │
├─────────────────────────────────────────────────────────────┤
│  Storage Layer        │ Fichiers système sécurisés          │
└─────────────────────────────────────────────────────────────┘
```

## Chiffrement quantique résistant

### Algorithme : ChaCha20-Poly1305

Le projet utilise ChaCha20-Poly1305, un algorithme de chiffrement authentifié qui est considéré comme résistant aux attaques quantiques à court terme.

#### Caractéristiques

- **ChaCha20** : Chiffrement de flux haute performance
- **Poly1305** : Authentification cryptographique
- **Résistance quantique** : Résistant aux attaques par ordinateur quantique
- **Performance** : Plus rapide qu'AES sur certains processeurs

#### Paramètres

```python
# Configuration du chiffrement
ALGORITHM = "ChaCha20-Poly1305"
KEY_SIZE = 32  # 256 bits
NONCE_SIZE = 12  # 96 bits
TAG_SIZE = 16  # 128 bits (intégré dans Poly1305)
```

### Gestion des clés

#### Génération des clés

```typescript
// Génération d'une clé aléatoire (32 bytes)
const key = VaultCrypto.generateKey();

// Dérivation depuis un mot de passe
const derivedKey = VaultCrypto.hashToKey('mon-mot-de-passe-secret');

// Validation de la clé
const isValid = VaultCrypto.validateKey(key);
```

#### Stockage des clés

- **Développement** : Clé de démonstration intégrée
- **Production** : Clés générées dynamiquement ou via HSM
- **Rotation** : Support de la rotation des clés
- **Validation** : Vérification stricte de la taille (32 bytes)

### Processus de chiffrement

#### Côté serveur (API)

```python
def encrypt_content(content: str, key: bytes) -> bytes:
    # Génération d'un nonce aléatoire
    nonce = os.urandom(12)

    # Création du chiffreur
    cipher = ChaCha20Poly1305(key)

    # Chiffrement avec authentification
    encrypted = cipher.encrypt(nonce, content.encode('utf-8'), None)

    # Retour : nonce + données chiffrées
    return base64.b64encode(nonce + encrypted)
```

#### Côté client (SDK)

```typescript
private decryptContent(encryptedContent: Buffer): string {
    // Décodage base64
    const decoded = Buffer.from(encryptedContent.toString(), 'base64');

    // Extraction du nonce (12 premiers bytes)
    const nonce = decoded.subarray(0, 12);
    const ciphertext = decoded.subarray(12);

    // Déchiffrement
    const decipher = createDecipher('chacha20-poly1305', this.decryptionKey, nonce);
    let decrypted = decipher.update(ciphertext, undefined, 'utf8');
    decrypted += decipher.final('utf8');

    return decrypted;
}
```

## Sécurité du transport (HTTPS)

### Configuration TLS

```python
# Configuration SSL sécurisée
context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
context.minimum_version = ssl.TLSVersion.TLSv1_2
context.set_ciphers('ECDHE+AESGCM:ECDHE+CHACHA20:DHE+AESGCM:DHE+CHACHA20:!aNULL:!MD5:!DSS')
```

#### Suites cryptographiques supportées

- **ECDHE+AESGCM** : Échange de clés elliptique + AES-GCM
- **ECDHE+CHACHA20** : Échange de clés elliptique + ChaCha20
- **DHE+AESGCM** : Échange de clés Diffie-Hellman + AES-GCM
- **DHE+CHACHA20** : Échange de clés Diffie-Hellman + ChaCha20

#### Protocoles interdits

- **TLS 1.0/1.1** : Versions obsolètes
- **SSL** : Protocole obsolète
- **NULL** : Chiffrement nul
- **MD5** : Hash faible
- **DSS** : Algorithme faible

### Certificats

#### Développement
- **Type** : Certificats auto-signés
- **Génération** : Automatique au démarrage
- **Validation** : Désactivée côté client (`verifySsl: false`)

#### Production
- **Type** : Certificats signés par une CA
- **Validation** : Obligatoire côté client
- **Rotation** : Automatique avant expiration

## Contrôle d'accès

### Validation des chemins

```python
def validate_path(env: str, file_path: str) -> bool:
    # Construction du chemin complet
    full_path = STORAGE_ROOT / env / file_path

    # Vérification de sécurité
    if not str(full_path.resolve()).startswith(str(STORAGE_ROOT.resolve())):
        return False

    # Vérification de l'existence
    return full_path.exists() and full_path.is_file()
```

#### Protection contre

- **Traversée de répertoires** : `../../../etc/passwd`
- **Chemins absolus** : `/etc/passwd`
- **Accès hors storage** : Toute tentative d'accès en dehors du répertoire `storage/`

### Variables d'environnement

#### Traitement sécurisé

```python
def resolve_variable(var_name: str, visited: set = None) -> str:
    # Détection des dépendances circulaires
    if visited is None:
        visited = set()

    if var_name in visited:
        logger.warning(f"Dépendance circulaire détectée pour {var_name}")
        return f"${{{var_name}}}"

    # Résolution récursive sécurisée
    visited.add(var_name)
    value = self.variables[var_name]

    # Traitement des sous-variables
    pattern = r'\$\{([^}]+)\}'
    matches = re.findall(pattern, value)

    for match in matches:
        resolved_value = self._resolve_variable(match, visited.copy())
        value = value.replace(f"${{{match}}}", resolved_value)

    return value
```

#### Sécurité des variables

- **Validation** : Vérification de la syntaxe des variables
- **Circularité** : Détection des dépendances circulaires
- **Injection** : Protection contre l'injection de code
- **Limitation** : Limite de profondeur de résolution

## Audit et monitoring

### Logging sécurisé

```python
# Logs d'accès
logger.info(f"Served file: {env}/{file_path}")

# Logs d'erreur
logger.error(f"Erreur lors du service du fichier {env}/{file_path}: {e}")

# Logs de sécurité
logger.warning(f"Tentative d'accès non autorisé: {file_path}")
```

#### Types de logs

- **Accès** : Tous les accès aux fichiers
- **Erreurs** : Erreurs de traitement et de chiffrement
- **Sécurité** : Tentatives d'accès non autorisé
- **Performance** : Métriques de performance

### Métriques de sécurité

```python
# Métriques collectées
security_metrics = {
    'failed_decryptions': 0,
    'unauthorized_access_attempts': 0,
    'invalid_paths_attempted': 0,
    'circular_dependency_detections': 0
}
```

## Gestion des secrets

### Clés de chiffrement

#### Développement
```python
# Clés de session dynamiques générées automatiquement
# Plus de clé fixe exposée dans le code
```

#### Production
```python
# Génération sécurisée des clés
def generate_production_key():
    # Utilisation d'un générateur cryptographiquement sécurisé
    return os.urandom(32)

# Stockage sécurisé (exemple avec HSM)
def load_key_from_hsm(key_id: str):
    # Intégration avec un Hardware Security Module
    return hsm_client.get_key(key_id)
```

### Rotation des clés

```python
class KeyRotationManager:
    def __init__(self):
        self.current_key = self.load_current_key()
        self.next_key = self.generate_next_key()

    def rotate_keys(self):
        # Rotation des clés
        old_key = self.current_key
        self.current_key = self.next_key
        self.next_key = self.generate_next_key()

        # Nettoyage de l'ancienne clé
        self.secure_delete(old_key)
```

## Bonnes pratiques de sécurité

### Développement

#### Clés dynamiques
```typescript
// ✅ Bon : Pas de clé en dur, clés dynamiques automatiques
const client = new VaultClient({
  baseUrl: 'https://vault.4nkweb.com:6666'
});

// ❌ Mauvais : Clé fixe exposée dans le code
const client = new VaultClient({
  baseUrl: 'https://vault.4nkweb.com:6666'
}, 'fixed-key-here'); // Déprécié
```

#### Validation des entrées
```typescript
// ✅ Bon : Validation stricte
if (!VaultCrypto.validateKey(key)) {
  throw new Error('Clé invalide');
}

// ❌ Mauvais : Pas de validation
const cipher = createDecipher('chacha20-poly1305', key);
```

### Production

#### Configuration sécurisée
```python
# ✅ Bon : Configuration de production
PRODUCTION_CONFIG = {
    'verify_ssl': True,
    'cert_validation': True,
    'key_rotation_interval': 86400,  # 24h
    'max_file_size': 10 * 1024 * 1024,  # 10MB
    'rate_limit': 100  # req/min
}
```

#### Monitoring
```python
# ✅ Bon : Monitoring de sécurité
def log_security_event(event_type: str, details: dict):
    security_logger.warning({
        'event': event_type,
        'timestamp': datetime.utcnow(),
        'details': details,
        'severity': 'HIGH'
    })
```

## Conformité et standards

### Standards de chiffrement

- **NIST SP 800-57** : Recommandations pour la gestion des clés
- **FIPS 140-2** : Standards pour les modules cryptographiques
- **Common Criteria** : Évaluation de la sécurité des produits IT

### Algorithmes approuvés

- **ChaCha20** : RFC 8439
- **Poly1305** : RFC 8439
- **SHA-256** : FIPS 180-4
- **TLS 1.2+** : RFC 5246, RFC 8446

### Résistance quantique

Le choix de ChaCha20-Poly1305 offre une résistance quantique à court terme :

- **Attaques classiques** : Résistance prouvée
- **Attaques quantiques** : Résistance estimée jusqu'en 2030
- **Migration** : Plan de migration vers des algorithmes post-quantiques

## Incident Response

### Procédure d'incident

1. **Détection** : Monitoring automatique des anomalies
2. **Analyse** : Investigation des logs et métriques
3. **Containment** : Isolation des systèmes affectés
4. **Éradication** : Correction des vulnérabilités
5. **Récupération** : Remise en service sécurisée
6. **Lessons learned** : Amélioration des procédures

### Contacts de sécurité

- **Équipe sécurité** : security@4nkweb.com
- **Incident response** : incident@4nkweb.com
- **Urgence** : +33 1 XX XX XX XX

## Mise à jour et maintenance

### Gestion des vulnérabilités

```python
# Processus de mise à jour de sécurité
def update_security_patches():
    # Vérification des mises à jour
    patches = check_security_updates()

    for patch in patches:
        if patch.severity >= 'HIGH':
            apply_patch(patch)
            notify_security_team(patch)
```

### Tests de sécurité

```bash
# Tests de sécurité automatisés
npm run test:security
python3 -m pytest tests/security/

# Audit de sécurité
npm audit
pip-audit
```

---

**Dernière révision** : 2025-09-29
**Version** : 1.0.0
**Prochaine révision** : 2025-12-29