# 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