Guide till säkra REST API:er för WordPress med grundläggande autentisering

Översikt

Grundläggande autentisering för REST API:er i WordPress säkrar åtkomst till WordPress-slutpunkter genom att validera API-förfrågningar med en token som genereras från ett användarnamn och lösenord eller klientuppgifter. Denna autentiseringsmetod bekräftar användaridentitet vid interaktion med webbtjänsten, vilket säkerställer att endast behöriga användare kan komma åt REST API för WordPress.

Hämta Plugin

Pröva På

demo Video

Hur implementerar man grundläggande autentisering i WordPress för att säkra REST API:er?

Basic Auth-pluginet i WordPress hjälper till att säkra REST API:er med hjälp av grundläggande autentisering. Med den här metoden skickar varje API-förfrågan inloggningsuppgifter (användarnamn eller e-postadress och lösenord) kodade i base64, vilket säkerställer säker kommunikation mellan din WordPress-webbplats och externa applikationer.

REST API-autentiseringsplugin för WordPress

REST API-autentiseringspluginet för WordPress ger skydd mot obehörig åtkomst till dina REST API:er för WordPress. Vårt plugin erbjuder flera autentiseringsmetoder som grundläggande autentisering, API-nyckelautentisering, OAuth 2.0-autentisering och JWT-autentisering.

Lär dig mer

Visa för att konfigurera grundläggande autentisering för REST API för WordPress?

För att konfigurera WP API Basic Auth måste du installera en REST API-autentiseringsplugin för WordPressDetta plugin tillåter REST API för WordPress att acceptera grundläggande autentiseringsuppgifter för säker åtkomst.

Steg-för-steg-guide:

Steg 1: Installera plugin-programmet - Sök efter "REST API Authentication for WP" i WordPress plugin-arkiv och installera det. Detta plugin aktiverar REST API Basic Authentication på din webbplats.
Steg 2: Aktivera insticksprogrammet - När pluginet är installerat aktiverar du det från din WordPress-instrumentpanel genom att gå till Plugins → Installerade plugins och klicka på "Aktivera" bredvid REST API Authentication-pluginet.
Steg 3: Konfigurera autentisering - Öppna plugin-inställningarna och följ stegen för att konfigurera grundläggande autentisering för ditt REST API. Gå till plugin-programmets konfigurationssida för att konfigurera din autentiseringsmetod.

Användningsfall: Hur förbättrar man säkerheten för REST API-slutpunkter för WordPress med grundläggande autentisering?

1. Använda användarnamn och lösenord för säker interaktion med REST API för WordPress

Om du utvecklar en Android- eller iOS-app som låter användare publicera sina egna flöden eller bloggar är det avgörande att säkerställa säkra och autentiserade interaktioner med REST API för WordPress.

Så här hanterar du användarautentisering på ett säkert sätt:

Använd grundläggande autentisering för WordPress: Implementera grundläggande autentisering för WordPress REST API med användarnas användarnamn och lösenord. Den här metoden säkerställer att förfrågningar som görs via din app autentiseras på ett säkert sätt.
Autentisera användarförfrågningar: När en användare loggar in i din app skapas en session och användarens inloggningsuppgifter skickas i krypterat format i huvudet för grundläggande auktorisering.
Hantera behörigheter: Baserat på användarens WordPress-behörigheter avgör REST API vilka åtgärder de har tillstånd att utföra och vilket innehåll de har åtkomst till. Detta hjälper till att kontrollera användarnas möjligheter och upprätthålla säkra interaktioner med din WordPress-webbplats.

Genom att använda grundläggande autentisering för WordPress med användaruppgifter säkerställer du att varje användares handlingar autentiseras och auktoriseras korrekt, vilket ger en säker miljö för användargenererat innehåll.

REST API Basic Authentication method för WordPress med hjälp av användaruppgifter

2. Använda klientuppgifter för säker interaktion med REST API för WordPress

Om du har en Android- eller iOS-app och behöver interagera med WordPress-innehåll via dess REST API är det viktigt att skydda din webbplats från obehörig åtkomst. Istället för att använda WordPress-användaruppgifter direkt, vilket kan vara riskabelt, bör du välja grundläggande autentisering för WordPress med klientuppgifter.

Så här använder du klientuppgifter på ett säkert sätt:

Skaffa klient-ID och klienthemlighet: Istället för att avslöja WordPress-användaruppgifter, generera ett klient-ID och klienthemlighet för din app.
Skicka säkra förfrågningar: När du gör API-förfrågningar, inkludera klient-ID och klienthemlighet. Dessa referenser sänds i ett krypterat format i huvudet för grundläggande auktorisering.
Validering och åtkomst: När REST API:et för WordPress tar emot din begäran validerar det klientuppgifterna. Om valideringen lyckas får du tillgång till de API-slutpunkter du behöver, samtidigt som din webbplats hålls säker.

Genom att använda klientuppgifter ser du till att din WordPress-användarinformation förblir skyddad samtidigt som din app fortfarande kan interagera med din WordPress-webbplats på ett effektivt sätt.

REST API Basic Authentication method för WordPress med klientuppgifter

enkel inloggning (SSO) för WordPress - integration med tillägg för inloggningsformulär

API-nyckelautentisering

JWT-autentisering

OAuth 2.0-autentisering

enkel inloggning (SSO) för WordPress - rollmappning i Discord

Tredjepartsleverantörsautentisering

Konfigurationssteg för REST API Basic Authentication för WordPress

Gratis
Premium

Använda grundläggande autentisering med REST API: Användarnamn och lösenord

I plugin, gå till Konfigurera metoder fliken i det vänstra avsnittet.
Klicka på Grundläggande autentisering som API-autentiseringsmetod.

REST API Basic Authentication method för WordPress med användarnamn och lösenord

Välja Användarnamn och lösenord med Base64-kodning och klicka Nästa i det övre högra hörnet.

För att testa funktionaliteten, fyll i användarnamn och lösenord för en befintlig användare.

Du kan redigera REST API-slutpunkten för att hämta detaljer från den slutpunkten. Exempel: /pages endpoint har valts här:
Klicka på Testkonfiguration och verifiera resultatet som visas på skärmen.
Klicka på Finish knapp.

REST API Basic Auth med klient-ID och klienthemlighet:

Gå till i plugin-programmet Konfigurera API-autentisering fliken och klicka på Grundläggande autentisering som API-autentiseringsmetod.
Välj nu Client-ID: Client-Secret som grundläggande autentiseringsnyckeltyp och välj någon av de tillgängliga krypteringsmetoderna som beror på hur du vill koda användaruppgifterna. HMAC är den säkraste bland dessa och den rekommenderade.
Slutligen klickar du på Spara konfiguration så grundläggande autentisering för WordPress REST API-autentisering kommer att aktiveras.

REST API Basic Authentication method för WordPress med hjälp av client-id och client-secret

När du har sparat REST API Basic Auth-konfigurationen måste du skicka en REST API-förfrågan med din respektive auktoriseringsnyckel för att komma åt REST API:erna för WordPress. Du måste använda förfrågningsformatet som visas nedan.

  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"

PHP base64_encode(string) funktion för base64-kodning kan användas enligt följande:

        
   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==

Kolla in Felsvar för Basic Auth med klient-ID och klienthemlighet.
Kolla in utvecklarens dokumentation för mer detaljer.

Kodprover i programmeringsspråk

Användarnamn Lösenord
Kunduppgifter

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

Postman prover:

Följ stegen nedan för att göra REST API-begäran med Postman:

Klicka på Postman prover fliken i plugin-programmet.

REST API Basic Authentication method för WordPress Postman-implementering

Håll nu muspekaren över kortet Basic Authentication Postman Samples.

a) För användarnamn-lösenord

REST API Grundläggande autentiseringsmetod för WordPress Postman JSON-fil för användarnamn: lösenord

Importera det nedladdade JSON-fil i Postman Application enligt nedan.

REST API Grundläggande autentiseringsmetod för WordPress Postman-import av JSON-filer

När du har importerat json-filen klickar du på REST API-begäran under samlingarna som visas i den sista bilden. Byt ut med din Wordpress-domän i http://<wp_base_url>/wp-json/wp/v2/posts och byt ut base64-kodad i rubriken med det kodade basvärdet.

Exempel:
För användarnamn: testanvändare och lösenord: password@123 kommer det base64-kodade värdet att vara 'dGVzdHVzZXI6cGFzc3dvcmRAMTIz'

WordPress REST API Autentiseringsnyckelmetod postman ersätter bas-url

b) För klient-ID och klienthemlighet

REST API Grundläggande autentiseringsmetod för WordPress Postman JSON-fil för klient-ID och klienthemlighet

Importera det nedladdade JSON-fil i Postman Application enligt nedan.

När du har importerat json-filen klickar du på REST API-begäran under samlingarna som visas i den sista bilden. Byt nu ut med din Wordpress-domän i http://<wp_base_url>/wp-json/wp/v2/posts och byt ut base64-kodad i rubriken med det kodade basvärdet.

REST API Basic Authentication method för WordPress Postman ersätter bas-URL

Funktionsbeskrivning

1. Rollbaserad REST API-begränsning:

Den här funktionen begränsar åtkomst till REST API för WordPress baserat på användarroller. Du kan tillåta specifika roller som har åtkomst till vissa REST API-resurser. När en REST API-begäran görs kontrolleras användarens roll och åtkomst beviljas endast om rollen finns på tillåtelselistan.

Hur konfigurerar man rollbaserade REST API-begränsningar i WordPress?

Gå till pluginet avancerade inställningar fliken.
I Rollbaserad begränsning avsnittet har alla roller som standard åtkomst till API:er.
Markera kryssrutan bredvid de roller du vill begränsa från att komma åt API:erna.

I bilden ovan är kryssrutan prenumerantroll aktiverad. Så närhelst en API-begäran görs av användaren, med sin roll som prenumerant, kommer den användaren inte att få åtkomst till den begärda resursen.

Obs: Den rollbaserade begränsningsfunktionen är giltig för grundläggande autentisering (användarnamn: lösenord), JWT-metoden och OAuth 2.0 (lösenordsbeviljande).

2. Anpassad rubrik:

Funktionen Anpassad rubrik låter dig använda en anpassad rubrik istället för standardrubriken "Auktorisering". Detta lägger till ett extra säkerhetslager eftersom REST API bara accepterar förfrågningar med ditt definierade anpassade rubriknamn. Om någon försöker skicka en begäran med standardrubriken "Auktorisering" kommer åtkomst att nekas.

Hur konfigurerar man en anpassad header för REST API-autentisering för WordPress?

Gå till pluginet avancerade inställningar fliken.
I Anpassa sidhuvud ange ditt önskade rubriknamn i textrutan i avsnittet.
Spara ändringarna för att tillämpa den nya anpassade rubriken för API-förfrågningar.

3. Uteslut REST API:er:

Funktionen Exkludera REST API:er låter dig tillåta åtkomst till specifika REST API-slutpunkter utan autentisering. Dessa exkluderade API:er blir offentligt tillgängliga, vilket gör dem tillgängliga utan att det krävs en token eller inloggning.

Hur konfigurerar man ett undantaget REST API i JWT-autentisering?

Gå till pluginet avancerade inställningar fliken.
I Uteslut REST API:er avsnittet, ange dina API-slutpunkter i önskat format.
De angivna API:erna kommer att exkluderas från autentisering och vara tillgängliga för allmänheten.

Exempel: Anta att du vill utesluta REST API '/wp-json/wp/v2/posts' så måste du ange '/wp/v2/posts' i textrutan.

4. Aktivera avancerad kryptering för tokens med HMAC:

Den här funktionen är tillgänglig i metoden Basic Authentication. Som standard krypteras tokens med Base64-kodning, men med det avancerade alternativet kan du aktivera HMAC-kryptering för tokens. HMAC ger en mycket högre säkerhetsnivå, vilket säkerställer att API-förfrågningar är starkt skyddade mot manipulering och obehörig åtkomst.

Hur konfigurerar man HMAC-kryptering för tokens i WordPress för grundläggande autentisering?

Gå till pluginet avancerade inställningar fliken och öppna Token-krypteringsmetod sektion.
Välja HMAC istället för Base64, spara sedan ändringarna för att tillämpa säker kryptering för alla tokens.

Vanliga frågor (FAQ)

Är grundläggande autentisering för WordPress säker?

Som standard använder grundläggande autentisering Base64-kodning, vilket inte är helt säkert. Med plugins som vårt kan du dock aktivera avancerad HMAC-kryptering, vilket gör tokens säkrare och lämpligare för produktionsanvändning.

När ska jag använda grundläggande autentisering istället för JWT?

Grundläggande autentisering är idealisk för testning, utveckling eller småskaliga appar där enkelhet är viktigt. JWT rekommenderas för större applikationer som behöver tokenbaserade sessioner och skalbarhet.

Kan jag använda grundläggande autentisering med mobilappar (Android/iOS)?

Ja. Grundläggande autentisering kan användas med användarautentiseringsuppgifter eller klientautentiseringsuppgifter i mobilappar för att säkert validera API-förfrågningar.

Vad händer om jag inaktiverar grundläggande autentisering?

Om den är inaktiverad kommer dina REST API-slutpunkter inte längre att validera förfrågningar med grundläggande autentisering. Detta kan göra ditt API öppet för obehörig åtkomst, så det rekommenderas att alltid hålla autentiseringen aktiverad.

Hur kan jag begränsa API-åtkomst baserat på användarroller?

Med funktionen Rollbaserad begränsning kan du ange vilka WordPress-roller som får eller inte får åtkomst till dina REST API-slutpunkter.

Begär en demo av plugin-programmet

Få en komplett provversion

Tack för ditt svar. Vi återkommer snart.

Något gick fel. Skicka din fråga igen

Integrera externa/tredje parts REST API-slutpunkter

Behöver hjälp?

Maila oss vidare apisupport@xecurify.com för snabb vägledning (via e-post/möte) om ditt krav och vårt team hjälper dig att välja den bästa lämpliga lösningen/planen enligt dina krav.

Innehåll