Contrôle d'accès défaillant dans les plugins WordPress
Contrôle d'accès défaillant dans les plugins WordPress : sécurisez les gestionnaires AJAX, admin-post et REST avec capacités, nonces et vérification de propriété.
Aussi en : English Deutsch Español Italiano Polski Português Türkçe
La plupart des bugs de contrôle d'accès défaillant dans les plugins WordPress viennent d'une seule ligne manquante : une vérification de capacité que personne n'a écrite. Le gestionnaire fonctionne, le nonce est contrôlé, la fonctionnalité est livrée, et n'importe quel utilisateur connecté avec le rôle Abonné peut l'appeler. Cet article s'adresse aux développeurs de plugins et de thèmes, ainsi qu'aux agences qui écrivent des plugins sur mesure. Il présente les schémas de code à l'origine de ces bugs et les contrôles qui les évitent.
Pourquoi le contrôle d'accès défaillant domine les failles exploitées dans les plugins WordPress
Le rapport State of WordPress Security in 2026 de Patchstack est un rapport d'éditeur qui porte sur les données de 2025. Il constate que le contrôle d'accès défaillant était la catégorie la plus exploitée. Le même rapport dénombre 11 334 nouvelles vulnérabilités dans l'écosystème WordPress, dont 91 % dans des plugins. Pour les failles très exploitées, le délai médian pondéré avant une exploitation de masse était de 5 heures. Si vous livrez une faille, vous n'aurez pas des jours pour la corriger.
Pour un plugin, le contrôle d'accès défaillant désigne un gestionnaire de requêtes qui modifie ou révèle des données sans vérifier qui demande ni ce que cette personne a le droit de toucher. Chaque gestionnaire doit répondre à quatre questions, dans cet ordre :
- L'utilisateur est-il connecté ? Ne sautez cette étape que si l'action est réellement publique.
- A-t-il le droit de le faire ? C'est la vérification de capacité.
- Voulait-il vraiment le faire ? C'est la vérification du nonce, contre la CSRF.
- A-t-il le droit de toucher cet objet précis ? C'est une vérification de propriété ou de méta-capacité sur l'identifiant.
Commencez par recenser tous les points d'entrée de votre plugin
On ne sécurise pas des gestionnaires dont on ignore l'existence. Chaque endroit où une requête atteint votre code est une porte. Cela comprend les hooks wp_ajax_ et wp_ajax_nopriv_, les hooks admin_post_ et admin_post_nopriv_, et les appels à register_rest_route(). Cela comprend aussi les gestionnaires branchés sur init ou template_redirect qui lisent $_POST ou $_GET, ainsi que les shortcodes ou blocs qui traitent des données de formulaire.
Lancez ces commandes depuis le répertoire racine de votre plugin :
# Points d'entrée enregistrés
grep -rnE "wp_ajax_|admin_post_|register_rest_route" --include='*.php' .
# Les points publics méritent un second regard
grep -rn "wp_ajax_nopriv_\|admin_post_nopriv_\|__return_true" --include='*.php' .
# Données brutes de la requête lues n'importe où
grep -rn '\$_POST\|\$_GET\|\$_REQUEST' --include='*.php' .
Consignez les résultats dans un tableau, une ligne par point d'entrée. Conservez-le dans le dépôt, à côté du code :
| Point d'entrée | Type | Qui peut l'appeler |
|---|---|---|
myplugin_save_settings | AJAX | manage_options |
myplugin_export | admin-post | myplugin_export_entries |
GET /myplugin/v1/stats | REST | Public, lecture seule |
Si vous ne parvenez pas à remplir la dernière colonne pour un point d'entrée, vous venez de trouver votre premier bug.
Gestionnaires AJAX : wp_ajax_nopriv_ et le current_user_can() manquant
wp_ajax_nopriv_{action} rend une action accessible sans aucune connexion. Ne l'enregistrez que pour des actions réellement publiques, comme une recherche en front-end. Les développeurs l'ajoutent souvent « pour que le formulaire fonctionne aussi pour les visiteurs » et oublient que le gestionnaire supprime ou exporte des données.
wp_ajax_{action} seul n'est pas non plus une vérification de permission. Il signifie que n'importe quel utilisateur connecté peut appeler l'action, Abonnés compris. Ne vous fiez pas à is_admin(). Cette fonction renvoie vrai pour toute requête vers admin-ajax.php et admin-post.php, car ces fichiers se chargent dans le contexte d'administration. Elle indique où la requête a atterri, pas qui l'a envoyée.
Un gestionnaire qui répond aux questions :
add_action( 'wp_ajax_myplugin_delete_entry', 'myplugin_ajax_delete_entry' );
// Volontairement aucun hook wp_ajax_nopriv_.
function myplugin_ajax_delete_entry() {
if ( ! current_user_can( 'myplugin_manage_entries' ) ) {
wp_send_json_error( array( 'message' => 'Forbidden' ), 403 );
}
// Termine avec un 403 si le nonce est absent ou invalide.
check_ajax_referer( 'myplugin_delete_entry', 'nonce' );
$entry_id = isset( $_POST['entry_id'] ) ? absint( $_POST['entry_id'] ) : 0;
// ...la vérification de propriété et le traitement proprement dit suivent (voir plus bas).
wp_send_json_success();
}
Les vérifications de capacité et de nonce peuvent s'exécuter dans l'ordre que vous voulez. L'essentiel est que les deux passent avant que le gestionnaire ne lise ou n'écrive quoi que ce soit. Utilisez une capacité personnalisée comme myplugin_manage_entries quand l'action ne doit pas dépendre des droits complets d'administrateur. manage_options convient quand seuls les administrateurs doivent y avoir accès.
Les gestionnaires admin_post_ obéissent aux mêmes règles. Seule la réponse diffère :
add_action( 'admin_post_myplugin_export', 'myplugin_handle_export' );
function myplugin_handle_export() {
if ( ! current_user_can( 'myplugin_export_entries' ) ) {
wp_die( esc_html__( 'You are not allowed to do this.', 'myplugin' ), '', array( 'response' => 403 ) );
}
check_admin_referer( 'myplugin_export' ); // s'associe à wp_nonce_field( 'myplugin_export' )
// ...
}
Les nonces protègent contre la CSRF, pas contre le mauvais utilisateur
Un nonce prouve que la requête provient d'un formulaire ou d'un lien généré par votre plugin. Il ne prouve pas que l'utilisateur a le droit d'effectuer l'action. Le manuel du développeur WordPress dit la même chose. Pourtant, de nombreux plugins vulnérables traitent encore un wp_verify_nonce() réussi comme une autorisation.
Un nonce ne peut pas servir d'autorisation, pour trois raisons :
- Quiconque peut charger la page qui affiche le nonce peut le lire dans le code source. Si votre nonce est imprimé sur chaque écran d'administration, ou en front-end, un Abonné l'a.
- Les nonces ne sont pas à usage unique. Par défaut, un nonce reste valide jusqu'à 24 heures.
- Les nonces créés pour des visiteurs non connectés sont partagés entre tous les visiteurs non connectés, et protègent donc très peu.
Associez chaque vérification de nonce à une vérification de capacité. Ne générez le nonce que sur les écrans affichés aux utilisateurs qui détiennent la capacité correspondante. Utilisez un nom d'action spécifique par opération, par exemple myplugin_delete_entry_42 ou au moins myplugin_delete_entry, plutôt qu'un unique myplugin_nonce pour tout le plugin.
Routes REST : écrivez un permission_callback qui vérifie vraiment
'permission_callback' => '__return_true' signifie « n'importe qui sur Internet ». Ne l'utilisez que pour des données publiques en lecture seule, déjà visibles ailleurs sur le site. Ne l'utilisez jamais sur des routes qui écrivent ou suppriment, ni sur celles qui renvoient des données personnelles ou des réglages.
add_action( 'rest_api_init', function () {
register_rest_route( 'myplugin/v1', '/entries/(?P<id>\d+)', array(
'methods' => WP_REST_Server::EDITABLE,
'callback' => 'myplugin_rest_update_entry',
'permission_callback' => function ( WP_REST_Request $request ) {
return current_user_can( 'edit_post', (int) $request['id'] );
},
'args' => array(
'id' => array(
'validate_callback' => function ( $value ) {
return is_numeric( $value );
},
'sanitize_callback' => 'absint',
),
'title' => array(
'type' => 'string',
'sanitize_callback' => 'sanitize_text_field',
),
),
) );
} );
Une vérification qui échoue doit renvoyer false ou un WP_Error. WordPress répond alors 401 aux requêtes anonymes et 403 aux utilisateurs connectés sans permission. Ne faites pas la vérification de permission dans callback : cela éclate la logique et complique les revues de code. Le manuel de l'API REST sur les points de terminaison personnalisés détaille la validation des args.
Les requêtes REST authentifiées par cookie, envoyées depuis votre propre JavaScript, doivent transmettre un nonce wp_rest dans l'en-tête X-WP-Nonce. Sans lui, WordPress traite la requête comme venant d'un visiteur non connecté. C'est une protection CSRF, pas une autorisation : le permission_callback doit donc toujours vérifier. Le point de terminaison natif des utilisateurs et les fuites de noms d'utilisateur forment un autre sujet, traité dans énumération des utilisateurs WordPress.
Ne faites jamais confiance à un identifiant d'objet issu de la requête
C'est le schéma de la référence directe non sécurisée à un objet (IDOR). Un gestionnaire reçoit dans la requête l'identifiant d'un article, d'une commande, d'une entrée ou d'un fichier, et l'utilise sans vérifier à qui il appartient. La vérification de capacité passe parce que l'utilisateur peut modifier certaines entrées, et rien ne l'empêche donc de modifier n'importe quelle entrée.
Pour les articles et les types de contenu personnalisés, utilisez les méta-capacités avec l'identifiant, par exemple current_user_can( 'edit_post', $post_id ) ou current_user_can( 'delete_post', $post_id ). Sans l'identifiant, WordPress ne peut pas rattacher la vérification à l'auteur, au statut et au type de l'article. Appeler current_user_can( 'edit_post' ) seul donne un résultat sans signification.
Pour les tables personnalisées, placez la vérification de propriété dans la requête elle-même :
global $wpdb;
$table = $wpdb->prefix . 'myplugin_entries';
$deleted = $wpdb->query(
$wpdb->prepare(
"DELETE FROM {$table} WHERE id = %d AND owner_id = %d",
$entry_id,
get_current_user_id()
)
);
if ( ! $deleted ) {
wp_send_json_error( array( 'message' => 'Not found' ), 404 );
}
Renvoyer un 404 plutôt qu'un 403 évite de confirmer que l'entrée de quelqu'un d'autre existe. Pour les actions de type « mon compte », prenez l'utilisateur via get_current_user_id() et n'acceptez jamais un user_id issu de la requête.
Prenons un plugin de formulaire de contact qui stocke les messages en base de données. Son action « exporter les entrées » est enregistrée sur wp_ajax_ avec une vérification de nonce, et rien d'autre. N'importe quel Abonné inscrit peut alors télécharger tous les messages jamais envoyés via le site. Dès que quelqu'un exploite cette faille, chaque site concerné subit une violation de données à caractère personnel au sens du RGPD, avec le délai de notification de 72 heures qui l'accompagne.
Checklist de revue du contrôle d'accès pour chaque version
- Chaque point d'entrée est listé avec son public prévu.
- Aucun hook
noprivn'existe sans une justification écrite dans le code. - Chaque gestionnaire appelle
current_user_can()avant de lire ou d'écrire des données. - Les nonces utilisent des noms d'action spécifiques et sont vérifiés dans chaque gestionnaire.
- Aucune route REST qui écrit, supprime ou renvoie des données privées n'utilise
__return_true. - Les identifiants d'objet sont vérifiés avec des méta-capacités ou une colonne de propriétaire.
- Les capacités personnalisées sont ajoutées à l'activation et retirées à la désinstallation.
- Le chemin d'erreur renvoie 401/403 (ou 404) sans divulguer de données ni de traces de pile.
- Des tests automatisés confirment qu'un Abonné et une requête non connectée sont refusés sur chaque action privilégiée.
- Chaque diff est relu pour repérer les nouveaux hooks, les nouvelles routes et les lectures de
$_POST/$_GET.
Ces tests sont peu coûteux à écrire avec l'environnement PHPUnit de WordPress :
public function test_subscriber_cannot_update_entry() {
wp_set_current_user( self::factory()->user->create( array( 'role' => 'subscriber' ) ) );
$request = new WP_REST_Request( 'POST', '/myplugin/v1/entries/' . $this->post_id );
$response = rest_get_server()->dispatch( $request );
$this->assertSame( 403, $response->get_status() );
}
Le plugin gratuit Security Audit & Compliance de secaudit.eu inclut une analyse de vulnérabilités du code (analyse de souillure, ou « taint ») des plugins et des thèmes. Considérez-la comme un second regard, pas comme un substitut à la relecture.
Quand on vous signale une faille : gestion des vulnérabilités et CRA
Un plugin ou un thème payant vendu à des clients de l'UE est un produit comportant des éléments numériques au sens du Cyber Resilience Act, et son vendeur en est le fabricant. Depuis le 11 septembre 2026, les vulnérabilités activement exploitées doivent être notifiées via la plateforme unique de notification de l'ENISA. Les délais sont une alerte précoce sous 24 heures, une notification sous 72 heures et un rapport final sous 14 jours après la mise à disposition d'un correctif. À partir du 11 décembre 2027, un processus de gestion des vulnérabilités et une politique de divulgation coordonnée seront obligatoires. Les détails figurent dans notre guide du CRA pour les vendeurs de plugins.
Rendez-vous facile à joindre avec un fichier security.txt et une boîte de réception que quelqu'un lit vraiment. Quand un signalement arrive, corrigez la faille et publiez la version. Rédigez une ligne de changelog qui nomme clairement le correctif de sécurité, et demandez aux clients de mettre à jour. Les conseils destinés aux propriétaires de sites pour appliquer ces mises à jour se trouvent dans Plugins WordPress vulnérables : auditer, mettre à jour, remplacer.
Votre prochaine étape, dès aujourd'hui : lancez les trois commandes grep ci-dessus sur votre plugin et remplissez le tableau des points d'entrée.
FAQ
is_user_logged_in() suffit-il à protéger une action ?
Non. Un Abonné est connecté lui aussi. is_user_logged_in() ne répond qu'à la première des quatre questions : ajoutez donc toujours une vérification de capacité.
Un nonce peut-il être réutilisé ?
Oui, pendant sa durée de vie, qui va jusqu'à 24 heures par défaut. Un nonce n'est ni un jeton à usage unique ni une permission : associez-le donc à current_user_can().
Peut-on se fier au rôle Abonné ?
Non. Sur de nombreux sites, n'importe qui peut s'inscrire comme Abonné (Réglages > Général > Adhésion). Considérez les comptes Abonné comme non fiables et testez chaque action privilégiée avec eux.
Cet article est une information générale et ne constitue pas un conseil juridique.
Vérifiez votre propre site
Security Audit & Compliance est l’extension WordPress de secaudit.eu : elle recherche les logiciels malveillants, le spam caché, les fichiers du cœur modifiés et le code vulnérable, et rattache ses constats à l’article 32 du RGPD, à l’article 21 de NIS2 et à l’OWASP Top 10.
Voir ce que vérifie l’extension