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

# 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

// 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)

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)

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

# 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

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é

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é

# 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é

# 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

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

Production

# 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

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

// ✅ 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

// ✅ 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

# ✅ 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

# ✅ 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

# 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é

# 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