Résultats de recherche :

×
S'inscrire Contactez-Nous

Table des matières

Guide pour sécuriser les API REST de WordPress avec l'authentification de base

Authentification de base WordPress pour les API REST Sécurise l'accès aux points de terminaison WordPress en validant les requêtes API avec un jeton généré à partir d'un nom d'utilisateur et d'un mot de passe, ou des identifiants client. Cette méthode d'authentification confirme l'identité de l'utilisateur lors de ses interactions avec le service web, garantissant ainsi que seuls les utilisateurs autorisés puissent accéder à l'API REST WordPress.

bouton de téléchargement du plug-in Télécharger le plugin plugin d'essai gratuit plugin d'essai gratuit Essai gratuit plugin d'essai gratuit plugin d'essai gratuit Vidéo de démonstration


Le plugin Basic Auth de WordPress sécurise les API REST grâce à l'authentification de base. Grâce à cette méthode, chaque requête API envoie des identifiants (nom d'utilisateur ou adresse e-mail et mot de passe) codés en base64, garantissant ainsi une communication sécurisée entre votre site WordPress et les applications externes.


Authentification de l'API REST WordPress

Le plugin d'authentification de l'API REST WordPress protège vos API REST WordPress contre tout accès non autorisé. Notre plugin propose plusieurs méthodes d'authentification, comme l'authentification de base, l'authentification par clé API, l'authentification OAuth 2.0 et l'authentification JWT.

Savoir Plus   


Pour configurer l'authentification de base de l'API WP, vous devez installer un Plugin d'authentification API REST WordPressCe plugin permet à l'API REST de WordPress d'accepter les informations d'authentification de base pour un accès sécurisé.


Guide étape par étape:


  • Étape 1 : Installer le plugin Recherchez « Authentification API REST pour WP » dans le répertoire des plugins WordPress et installez-la. Cette extension activera l'authentification API REST de base sur votre site.
  • Étape 2 : activer le plugin - Une fois installé, activez le plugin depuis votre tableau de bord WordPress en allant dans Plugins → Plugins installés et en cliquant sur « Activer » à côté du plugin d'authentification REST API.
  • Étape 3 : Configurer l’authentification Ouvrez les paramètres du plugin et suivez les étapes pour configurer l'authentification de base pour votre API REST. Accédez à la page de configuration du plugin pour configurer votre méthode d'authentification.


1. Utilisation du nom d'utilisateur et du mot de passe pour une interaction sécurisée avec l'API REST de WordPress


Si vous développez une application Android ou iOS qui permet aux utilisateurs de publier leurs propres flux ou blogs, il est essentiel de garantir des interactions sécurisées et authentifiées avec l'API REST de WordPress.

Comment gérer en toute sécurité l’authentification des utilisateurs :

  • Utiliser l’authentification de base de WordPress : Implémentez l'API REST d'authentification de base de WordPress avec les noms d'utilisateur et les mots de passe des utilisateurs. Cette méthode garantit l'authentification sécurisée des requêtes effectuées via votre application.
  • Authentifier les demandes des utilisateurs : Lorsqu'un utilisateur se connecte à votre application, une session est créée et les informations d'identification de l'utilisateur sont envoyées dans un format crypté dans l'en-tête d'autorisation de base.
  • Gérer les autorisations: En fonction des autorisations WordPress de l'utilisateur, l'API REST détermine les actions qu'il est autorisé à effectuer et le contenu auquel il peut accéder. Cela permet de contrôler les capacités des utilisateurs et de sécuriser les interactions avec votre site WordPress.

En utilisant l'authentification de base WordPress avec les informations d'identification de l'utilisateur, vous vous assurez que les actions de chaque utilisateur sont correctement authentifiées et autorisées, offrant un environnement sécurisé pour le contenu généré par l'utilisateur.


Méthode d'authentification de base de l'API REST WordPress utilisant les informations d'identification de l'utilisateur

2. Utilisation des informations d'identification du client pour une interaction sécurisée avec l'API REST de WordPress


Si vous possédez une application Android ou iOS et devez interagir avec le contenu WordPress via son API REST, il est essentiel de protéger votre site contre tout accès non autorisé. Au lieu d'utiliser directement les identifiants utilisateur WordPress, ce qui peut être risqué, optez pour l'authentification WordPress de base avec les identifiants client.

Voici comment utiliser en toute sécurité les informations d’identification du client :

  • Obtenir l'ID client et le secret client : Au lieu d’exposer les informations d’identification de l’utilisateur WordPress, générez un ID client et un secret client pour votre application.
  • Envoyer des demandes sécurisées : Lors des requêtes API, veuillez inclure l'ID client et le secret client. Ces informations d'identification sont transmises sous forme chiffrée dans l'en-tête d'autorisation de base.
  • Validation et accès : Une fois que l'API REST WordPress reçoit votre requête, elle valide les identifiants du client. Si la validation est réussie, vous accédez aux points de terminaison API nécessaires, tout en sécurisant votre site.

En utilisant les informations d'identification du client, vous vous assurez que vos informations utilisateur WordPress restent protégées tout en permettant à votre application d'interagir efficacement avec votre site WordPress.


Méthode d'authentification de base de l'API REST WordPress utilisant les informations d'identification du client
intégration du module complémentaire de formulaire de connexion SSO à authentification unique WordPress

Authentification par clé API
intégration du module complémentaire de formulaire de connexion SSO à authentification unique WordPress

Authentification JWT
intégration du module complémentaire de restriction multimédia sso à authentification unique WordPress

Authentification OAuth 2.0
mappage des rôles Discord sso avec authentification unique wordpress

Authentification du fournisseur tiers


Utilisation de l'authentification de base avec l'API REST : nom d'utilisateur et mot de passe


  • Dans le plugin, allez dans le Configurer les méthodes onglet dans la section de gauche.
  • Cliquez sur L'authentification de base comme méthode d'authentification API.
    • Méthode d'authentification de base de l'API REST WordPress utilisant le nom d'utilisateur et le mot de passe
  • Choisir Nom d'utilisateur et mot de passe avec encodage Base64 et cliquez sur Suivant dans le coin supérieur droit.
    • Méthode d'authentification de base de l'API REST WordPress utilisant le nom d'utilisateur et le mot de passe
  • Afin de tester la fonctionnalité, remplissez les champs nom d'utilisateur et mot de passe pour un utilisateur existant.
    • Méthode d'authentification de base de l'API REST WordPress utilisant le nom d'utilisateur et le mot de passe
  • Vous pouvez modifier le point de terminaison de l'API REST pour en récupérer les détails. Exemple : le point de terminaison /pages a été sélectionné ici :
  • Cliquez sur le Configuration du test et vérifiez le résultat affiché à l'écran.
  • Cliquez sur Finition .
    • Méthode d'authentification de base de l'API REST WordPress utilisant le nom d'utilisateur et le mot de passe

Authentification de base de l'API REST à l'aide de l'ID client et du secret client :


  • Dans le plugin, allez sur Configurer l'authentification API onglet et cliquez sur Authentification de base comme méthode d'authentification API.
  • Maintenant, sélectionnez le ID client : Client-Secret Choisissez le type de clé d'authentification de base et choisissez l'une des méthodes de chiffrement disponibles selon la méthode de cryptage des informations d'identification de l'utilisateur. HMAC est la plus sûre et la plus recommandée.
  • Enfin, cliquez sur Enregistrer la configuration donc l'authentification de base pour l'authentification de l'API REST WordPress sera activée.
    • Méthode d'authentification de base de l'API REST WordPress utilisant l'identifiant client et le secret client
  • Après avoir enregistré la configuration d'authentification de base de l'API REST, pour accéder aux API REST de WordPress, vous devez envoyer une requête API REST avec votre clé d'autorisation. Le format de requête doit être le suivant : 
    •   Request:  GET https://<domain-name>/wp-json/wp/v2/posts
  Header: Authorization: Basic base64encoded <client-id:client-secret>
    
  Sample Request Format-
  Example => Client ID : pSYQsKqTndNVpNKcnoZd and Client Secret : SrYPTViHdCbvkWyTfWrSltavTMeJjaOHCye
  
    
  Sample curl Request Format-
  curl -H "Authorization:Basic base64encoded <clientid:clientsecret>"
  -X POST http://<wp_base_url>/wp-json/wp/v2/users
  -d"username=test&email=test@test.com&password=test&name=test"
  • La fonction PHP base64_encode(string) pour l'encodage base64 peut être utilisée comme suit :
    •         
   base64_encode(‘pSYQsKqTndNVpNKcnoZd:SrYPTViHdCbvkWyTfWrSltavTMeJjaOHCye’) will results into 
  ‘cFNZUXNLcV RuZE5WcE5LY25vWmQ6U3JZUFRWaUhkQ2J2a1d5VGZXclNsdGF2VE1lSmphT0hDeWU=’ as output.
    
   Sample request: GET https://<domain-name>/wp-json/wp/v2/posts
   Header: Authorization :Basic eGw2UllOdFN6WmxKOlNMRWcwS1ZYdFVrbm5XbVV2cG9RVFNLZw==
  • Jetez un coup d'œil au Réponse d'erreur pour l'authentification de base à l'aide de l'ID client et du secret client.
  • Jetez un coup d'œil au documentation développeur pour plus de détails. 


 
  var client = new RestClient("http://<wp_base_url>/wp-json/wp/v2/posts ");
  client.Timeout = -1;
  var request = new RestRequest(Method.POST);
  request.AlwaysMultipartFormData = true;
  request.AddParameter("title", "Sample Post");
  request.AddParameter("status", "publish");
  IRestResponse response = client.Execute(request);
  Console.WriteLine(response.Content);
  
 
  OkHttpClient client  = new OkHttpClient().newBuilder().build();
  MediaType mediaType = MediaType.parse("text/plain");
  RequestBody body  = new MultipartBody.Builder().setType(MultipartBody.FORM)
  .addFormDataPart("title","Sample Post")
  .addFormDataPart("status", "publish") 
  .build();
  Request request  = new Request.Builder()
  .url("http://<wp_base_url>/wp-json/wp/v2/posts ")
  .method("POST", body)
   .build();
  Response responseclient.newCall(request).execute();
  
 
  var form = new FormData();
  form.append("title","Sample Post");
  form.append("status", "publish"); 
  
  var settings  = {
  "url": "http://<wp_base_url>/wp-json/wp/v2/posts ",
  "method": "POST",
  "timeout": 0,
  "processData": false,
  "mimeType": "multipart/form-data",
  "contentType": false,
  "data": form
  };
  
  $.ajax(settings).done(function (response)  {
  console.log(response);
  });
  
 
  <?php
   $curl = curl_init();
  curl_setopt_array($curl, array 
  (
  CURLOPT_URL => 'http://%3Cwp_base_url%3E/wp-json/wp/v2/posts%20',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'POST',
  CURLOPT_POSTFIELDS => array('title' => 'Sample Post','status' => 'publish'),
  ));
  
  $response = curl_exec($curl);
  curl_close($curl);    
  echo $response;
  
 
  import http.client
  import mimetypes
  from codecs import encode
  
  conn   = http.client.HTTPSConnection("<wp_base_url>")
  dataList= []
  boundary = 'wL36Yn8afVp8Ag7AmP8qZ0SA4n1v9T'
  dataList.append(encode('--' + boundary))
  dataList.append(encode('Content-Disposition: form-data; name=title;')) 
  
  dataList.append(encode('Content-Type: {}'.format('text/plain')))    
  dataList.append(encode(''))    
  
  dataList.append(encode("Sample Post"))
  dataList.append(encode('--' + boundary))    
  dataList.append(encode('Content-Disposition: form-data; name=status;'))    
  
  dataList.append('Content-Type: {}'.format('text/plain')))
  dataList.append(encode(''))    
  
  dataList.append(encode("publish")) 
  dataList.append(encode('--'+boundary+'--'))    
  dataList.append(encode(''))    
  body  = b'\r\n'.join(dataList)    
  payload= body
  headers = {
  'Content-type': 'multipart/form-data; boundary={}'.format(boundary) 
  }
  conn.request("POST", "/wp-json/wp/v2/posts ", payload, headers)
  res= conn.getresponse()    
  data = res.read()    
  print (data.decode("utf-8"))   
  
 
  var client = new RestClient("http://<wp_base_url>/wp-json/wp/v2/posts ");
  client.Timeout = -1;
  var request = new RestRequest(Method.POST);
  request.AddHeader("Authorization", "Basic base64encoded < clientid:clientsecret > ");
  request.AlwaysMultipartFormData = true;
  request.AddParameter("username", "test");
  request.AddParameter("email", "test@test.com");
  request.AddParameter("password", "test");
  request.AddParameter("name", "test");
  IRestResponse response = client.Execute(request);
  Console.WriteLine(response.Content);
  
 
  OkHttpClient client  = new OkHttpClient().newBuilder().build();
  MediaType mediaType = MediaType.parse("text/plain");
  RequestBody body  = new MultipartBody.Builder().setType(MultipartBody.FORM)
  .addFormDataPart("username","test")
  .addFormDataPart("email","test@test.com")
  .addFormDataPart("password","test")
  .addFormDataPart("name","test") 
  .build();
  Request request  = new Request.Builder()
  .url("http://<wp_base_url>/wp-json/wp/v2/posts ")
  .method("POST", body)
  .addHeader ("Authorization", "Basic base64encoded < clientid:clientsecret > ")
   .build();
  Response responseclient.newCall(request).execute();
  
 
  var form = new FormData();
  form.append("username", "test");
  form.append("email", "test@test.com");
  form.append("password", "test");
  form.append("name", "test");
  
  var settings  = {
  "url": "http://<wp_base_url>/wp-json/wp/v2/posts ",
  "method": "POST",
  "timeout": 0,
  "headers": {
  "Authorization": "Basic base64encoded < clientid:clientsecret > "
  },
  "processData": false,
  "mimeType": "multipart/form-data",
  "contentType": false,
  "data": form
  };
  
  $.ajax(settings).done(function (response)  {
  console.log(response);
  });
  
 
  <?php
   $curl = curl_init();
  curl_setopt_array($curl, array 
  ( 
  CURLOPT_URL => 'http://%3Cwp_base_url%3E/wp-json/wp/v2/users',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'POST',
  CURLOPT_POSTFIELDS => array('username' => 'test','email' => 'test@test.com','password' => 'test','name' => 'test'),
  CURLOPT_HTTPHEADER => array(
  'Authorization: Basic base64encoded < clientid:clientsecret > '
  ),
  ))  
  $response = curl_exec($curl);
  curl_close($curl);    
  echo $response;
  
 
  import http.client
  import mimetypes
  from codecs import encode
  
  conn   = http.client.HTTPSConnection("<wp_base_url>")
  dataList= []
  boundary = 'wL36Yn8afVp8Ag7AmP8qZ0SA4n1v9T'
  dataList.append(encode('--' + boundary))
  dataList.append(encode('Content-Disposition: form-data; name=username;'))
  
  dataList.append(encode('Content-Type: {}'.format('text/plain')))    
  dataList.append(encode(''))    
  
  dataList.append(encode("test"))
  dataList.append(encode('--' + boundary))    
  dataList.append(encode('Content-Disposition: form-data; name=email;'))
  
  dataList.append('Content-Type: {}'.format('text/plain')))
  dataList.append(encode(''))    
  
  dataList.append(encode("test@test.com"))
  dataList.append(encode('--'+ boundary))    
  dataList.append(encode('Content-Disposition: form-data; name=password;'))
  
  dataList.append(encode('Content-Type: {}'.format('text/plain')))
  dataList.append(encode(''))
  
  dataList.append(encode("test"))
  dataList.append(encode('--' + boundary))
  
  dataList.append(encode('Content-Disposition: form-data; name=name;'))
  
  dataList.append(encode('Content-Type: {}'.format('text/plain')))
  dataList.append(encode(''))
  
  dataList.append(encode("test"))
  dataList.append(encode('--'+boundary+'--'))
  dataList.append(encode(''))
  body  = b'\r\n'.join(dataList)    
  payload= body
  headers = {
  'Authorization': 'Basic base64encoded < clientid:clientsecret > ',
  'Content-type': 'multipart/form-data; boundary={}'.format(boundary) 
  }
  conn.request("POST", "/wp-json/wp/v2/posts ", payload, headers)
  res= conn.getresponse()    
  data = res.read()    
  print (data.decode("utf-8"))


    Suivez les étapes ci-dessous pour effectuer une requête API REST à l'aide de Postman :

  • Cliquez sur le Échantillons de facteur onglet dans le plugin.
    • Implémentation du postier de la méthode d'authentification de base de l'API REST WordPress
  • Maintenant, survolez la carte Basic Authentication Postman Samples.
        • API REST WordPress Méthode d'authentification de base Fichier JSON postman pour le nom d'utilisateur : mot de passe
      • Importez le fichier téléchargé Fichier JSON dans l'application Postman comme indiqué ci-dessous.
        • WordPress REST API Méthode d'authentification de base postman importer un fichier JSON
      • Une fois le fichier JSON importé, cliquez sur la requête API REST sous les Collections, comme indiqué dans la dernière figure. Remplacez le avec votre domaine Wordpress dans le http://<wp_base_url>/wp-json/wp/v2/posts et remplacer le codé en base64 dans l'en-tête avec la valeur codée de base.

          • Exemple :
          Pour le nom d'utilisateur : testuser et le mot de passe : password@123, la valeur codée en base64 sera « dGVzdHVzZXI6cGFzc3dvcmRAMTIz »

      WordPress REST API Méthode de clé d'authentification postman remplacer l'URL de base
        • WordPress REST API Méthode d'authentification de base Fichier JSON postman pour l'identifiant client et le secret client
      • Importez le fichier téléchargé Fichier JSON dans l'application Postman comme indiqué ci-dessous.
        • WordPress REST API Méthode d'authentification de base postman importer un fichier JSON
      • Une fois le fichier JSON importé, cliquez sur la requête API REST sous les Collections, comme illustré dans la dernière figure. Remplacez ensuite le avec votre domaine Wordpress dans le http://<wp_base_url>/wp-json/wp/v2/posts et remplacer le codé en base64 dans l'en-tête avec la valeur codée de base.
        • WordPress REST API Méthode d'authentification de base postman remplacer l'URL de base


1. Restriction de l'API REST basée sur les rôles :


Cette fonctionnalité restreint l'accès à l'API REST WordPress en fonction des rôles des utilisateurs. Vous pouvez autoriser certains rôles à accéder à certaines ressources de l'API REST. Lors d'une requête API REST, le rôle de l'utilisateur est vérifié et l'accès n'est accordé que si ce rôle figure sur la liste d'autorisation.


Comment configurer la restriction de l'API REST basée sur les rôles dans WordPress ?

  • Accéder au plugin Paramètres avancés languette.
  • Dans l' Restriction basée sur les rôles section, tous les rôles sont autorisés à accéder aux API par défaut.
  • Cochez la case en regard des rôles dont vous souhaitez restreindre l’accès aux API.
    • Implémentation du postier de la méthode d'authentification de base de l'API REST WordPress
  • Dans l'image ci-dessus, la case à cocher du rôle d'abonné est activée. Ainsi, chaque fois qu'une demande d'API est effectuée par l'utilisateur, avec son rôle d'abonné, cet utilisateur ne sera pas autorisé à accéder à la ressource demandée.

Note: La fonctionnalité de restriction basée sur les rôles est valide pour l’authentification de base (nom d’utilisateur : mot de passe), la méthode JWT et OAuth 2.0 (octroi de mot de passe).


2. En-tête personnalisé :


La fonctionnalité d'en-tête personnalisé vous permet d'utiliser un en-tête personnalisé au lieu de l'en-tête « Authorization » par défaut. Cela renforce la sécurité, car l'API REST n'accepte que les requêtes portant le nom d'en-tête personnalisé que vous avez défini. Si quelqu'un tente d'envoyer une requête avec l'en-tête « Authorization » par défaut, l'accès sera refusé.


Comment configurer un en-tête personnalisé pour l'authentification de l'API REST WordPress ?

  • Accéder au plugin Paramètres avancés languette.
  • Dans l' En-tête personnalisé section, entrez le nom de votre en-tête préféré dans la zone de texte.
  • Enregistrez les modifications pour appliquer le nouvel en-tête personnalisé aux requêtes API.
    • Implémentation du postier de la méthode d'authentification de base de l'API REST WordPress

3. Excluez les API REST :


La fonctionnalité « Exclure les API REST » vous permet d'autoriser l'accès à des points de terminaison d'API REST spécifiques sans authentification. Ces API exclues deviennent publiques, ce qui les rend accessibles sans jeton ni identifiant.


Comment configurer l'API REST exclue dans l'authentification JWT ?

  • Accéder au plugin Paramètres avancés languette.
  • Dans l' Exclure les API REST section, saisissez vos points de terminaison API au format requis.
  • Les API saisies seront exclues de l’authentification et disponibles pour l’accès public.
    • Implémentation du postier de la méthode d'authentification de base de l'API REST WordPress
  • Exemple : Supposons que vous souhaitiez exclure l'API REST '/wp-json/wp/v2/posts' puis vous devez saisir '/wp/v2/posts' dans la zone de texte.

4. Activez le cryptage avancé pour les jetons à l'aide de HMAC :


Cette fonctionnalité est disponible avec l'authentification de base. Par défaut, les jetons sont chiffrés en Base64, mais l'option avancée permet d'activer le chiffrement HMAC. HMAC offre un niveau de sécurité bien plus élevé, garantissant une protection renforcée des requêtes API contre toute falsification et tout accès non autorisé.


Comment configurer le cryptage HMAC pour les jetons dans l'authentification de base WordPress ?

  • Accéder au plugin Paramètres avancés onglet et ouvrez le Méthode de cryptage des jetons .
  • Choisir HMAC au lieu de Base64, puis enregistrez les modifications pour appliquer un cryptage sécurisé à tous les jetons.


Par défaut, l'authentification de base utilise le codage Base64, qui n'est pas totalement sécurisé. Cependant, grâce à des plugins comme le nôtre, vous pouvez activer un chiffrement HMAC avancé, rendant les jetons plus sûrs et adaptés à une utilisation en production.

L'authentification de base est idéale pour les tests, le développement ou les applications à petite échelle où la simplicité est essentielle. JWT est recommandé pour les applications plus volumineuses nécessitant des sessions basées sur des jetons et une évolutivité.

Oui. L'authentification de base peut être utilisée avec les identifiants utilisateur ou client dans les applications mobiles pour valider en toute sécurité les requêtes API.

Si cette option est désactivée, vos points de terminaison d'API REST ne valideront plus les requêtes avec l'authentification de base. Cela peut exposer votre API à des accès non autorisés ; il est donc recommandé de toujours maintenir l'authentification activée.

Grâce à la fonctionnalité de restriction basée sur les rôles, vous pouvez spécifier quels rôles WordPress sont autorisés ou non à accéder à vos points de terminaison d'API REST.




Obtenez un essai complet



 Merci pour votre réponse. Nous vous répondrons rapidement.

Quelque chose s'est mal passé. Veuillez soumettre à nouveau votre requête

Intégrer les points de terminaison de l'API REST externe/tierce

Besoin d'aide?

Envoyez-nous un e-mail apisupport@xecurify.com pour des conseils rapides (par e-mail/réunion) sur vos besoins et notre équipe vous aidera à sélectionner la solution/le plan le mieux adapté à vos besoins.


ADFS_sso ×
Bonjour!

Besoin d'aide? Nous sommes ici !

soutenez