Passport-OAuth-Authentifizierung


Laravel Passport

Einführung

In Laravel ist es sehr einfach, Anmeldung und Autorisierung auf der Grundlage herkömmlicher Formulare zu implementieren, aber wie erfüllt man die Autorisierungsanforderungen in API-Szenarien? In API-Szenarien wird die Benutzerautorisierung normalerweise über Token implementiert, anstatt den Sitzungsstatus zwischen Anforderungen aufrechtzuerhalten. Die Verwendung von Passport in Ihrem Laravel-Projekt erleichtert die Implementierung der API-Autorisierungsauthentifizierung. Passport kann in wenigen Minuten eine vollständige OAuth2-Serverimplementierung für Ihre Anwendung bereitstellen. Passport basiert auf dem League OAuth2-Server, der von Andy Millington und Simon Hamp verwaltet wird.

{note} In diesem Dokument wird davon ausgegangen, dass Sie bereits mit OAuth2 vertraut sind. Wenn Sie OAuth2 nicht kennen, machen Sie sich bitte vor dem Lesen mit den allgemeinen Begriffen und Funktionen von OAuth2 vertraut.

Installation

Bevor Sie beginnen, installieren Sie Passport über den Composer-Paketmanager: 

composer require laravel/passport

Reisepass Der Dienstanbieter verwendet das Framework, um sein eigenes Datenbankmigrationsverzeichnis zu registrieren. Nach der Registrierung des Anbieters sollten Sie daher den Migrationsbefehl von Passport ausführen, um automatisch die Datentabelle zum Speichern des Clients und des Tokens zu erstellen: 

php artisan migrate

Als nächstes führen Sie < aus 🎜> Befehl zum Erstellen der Verschlüsselungsschlüssel, die zum Generieren sicherer Zugriffstoken erforderlich sind. Gleichzeitig erstellt dieser Befehl auch den Client „Persönlicher Zugriff“ und den Client „Passwortautorisierung“, die zum Generieren von Zugriffstoken verwendet werden: passport:install

php artisan passport:install

Nachher Wenn Sie den obigen Befehl ausführen, fügen Sie bitte das

-Merkmal zum LaravelPassportHasApiTokens-Modell dieses Merkmals hinzu stellt Ihrem Modell einige Hilfsfunktionen zur Überprüfung des Tokens und des Nutzungsbereichs des authentifizierten Benutzers zur Verfügung: AppUser

<?php
    namespace App;
    use Laravel\Passport\HasApiTokens;
    use Illuminate\Notifications\Notifiable;
    use Illuminate\Foundation\Auth\User as Authenticatable;
    class User extends Authenticatable{ 
       use HasApiTokens, Notifiable;
     }

Als nächstes rufen Sie die Funktion

in der Methode AuthServiceProvider von boot auf. Diese Funktion registriert die Routen, die zum Ausstellen von Zugriffstokens und zum Widerrufen von Zugriffstokens, Client- und persönlichen Zugriffstokens erforderlich sind: Passport::routes

<?php
    namespace App\Providers;
    use Laravel\Passport\Passport;
    use Illuminate\Support\Facades\Gate;
    use Illuminate\Foundation\Support\Providers\AuthServiceProvider as ServiceProvider;
    class AuthServiceProvider extends ServiceProvider{ 
    /**
     * 应用程序的策略映射。
     *
     * @var array
     */   
     protected $policies = [  
           'App\Model' => 'App\Policies\ModelPolicy',  
            ];   
     /**
     * 注册任何认证/授权服务。
     *
     * @return void
     */   
     public function boot()
         {   
              $this->registerPolicies();        
              Passport::routes();    
         }
     }

Fügen Sie abschließend < zum Autorisierungsschutz

in der Konfigurationsdatei hinzu config/auth.php Das guards Option von 🎜> wird in api geändert. Diese Optimierung führt dazu, dass Ihre Anwendung bei der Validierung eingehender API-Anfragen Passports driver verwendet: passport

'guards' => [
    'web' => [ 
           'driver' => 'session',        
           'provider' => 'users',    
          ],    
     'api' => [   
              'driver' => 'passport',        
              'provider' => 'users',    
            ],
           ],
TokenGuard

Benutzerdefinierte Migration

Wenn Sie nicht die Standardmigration von Passport verwenden möchten, Sie sollten die

-Methode in der

-Methode aufrufen. Mit diesem Befehl AppServiceProvider können Sie Standardmigrationen exportieren. registerPassport::ignoreMigrationsStandardmäßig verwendet Passport das Feld „user_id“, um den Benutzer zu identifizieren. Wenn Sie ein anderes Feld zur Identifizierung des Benutzers verwenden möchten (z. B. uuid), können Sie die Standard-Passport-Migrationsdatei ändern. php artisan vendor:publish --tag=passport-migrations

Schneller Einstieg in das Frontend

{note} Um die Vue-Komponente von Passport nutzen zu können, müssen Sie das JavaScript-Framework Vue verwenden. Diese Komponenten verwenden auch das Bootstrap-CSS-Framework. Wenn Sie diese Tools jedoch nicht verwenden möchten, sind diese Komponenten auch für das Schreiben Ihrer eigenen Front-End-Komponenten wertvoll.

Passport bietet eine Reihe von JSON-APIs, die Sie verwenden können, um Ihren Benutzern die Erstellung von Client- und persönlichen Zugriffstokens zu ermöglichen. Allerdings kann das Schreiben des Front-End-Codes, der mit diesen APIs interagiert, zeitaufwändig sein. Daher enthält Passport auch vorkompilierte Vue-Komponenten, die Sie direkt oder als Referenz für Ihr eigenes Frontend verwenden können.

Um die Vue-Komponente von Passport zu verwenden, verwenden Sie den vendor:publish Artisan-Befehl: 

php artisan vendor:publish --tag=passport-components

Die veröffentlichte Komponente wird im Verzeichnis resources/js/components abgelegt. Wenn Komponenten veröffentlicht werden, sollten Sie sie in Ihrer resources/js/app.js-Datei registrieren: 

Vue.component(
    'passport-clients',    
    require('./components/passport/Clients.vue').default);
    Vue.component(
        'passport-authorized-clients',    
        require('./components/passport/AuthorizedClients.vue').default
       );
     Vue.component(
          'passport-personal-access-tokens',    
          require('./components/passport/PersonalAccessTokens.vue').default
        );

{note} Vor Laravel v5.7.19 führte das Hinzufügen von „.default“ beim Registrieren einer Komponente zu einem Konsolenfehler . Eine Erläuterung dieser Änderung finden Sie in den Versionshinweisen zu Laravel Mix v4.0.0.

Führen Sie nach der Registrierung der Komponente unbedingt npm run dev aus, um Ihre Ressourcen neu zu kompilieren. Nachdem Sie Ihre Ressourcen neu kompiliert haben, können Sie die Komponenten in die Vorlage Ihrer App einfügen, um mit der Erstellung von Client- und persönlichen Zugriffstokens zu beginnen: 

<passport-clients></passport-clients>
<passport-authorized-clients></passport-authorized-clients><
passport-personal-access-tokens></passport-personal-access-tokens>

Bereitstellung Passport

Wenn Sie Passport zum ersten Mal in Ihrer Produktionsumgebung bereitstellen, müssen Sie es wahrscheinlich ausführen passport:keys Befehl. Dieser Befehl generiert die Schlüssel, die Passport zum Generieren von Zugriffstokens benötigt. Generierte Schlüssel sollten generell nicht in die Versionskontrolle gestellt werden: 

php artisan passport:keys

Passport kann mit der Passport::loadKeysFrom-Methode angepasst werden Schlüsselladepfad: 

/**
 * 注册认证 / 授权服务
 *
 * @return void
 */
 public function boot(){
     $this->registerPolicies();    
     Passport::routes();    
     Passport::loadKeysFrom('/secret-keys/oauth');
    }

Konfiguration

Token-Gültigkeitsdauer

Standardmäßig Passport Der ausgestellte Zugangstoken ist ein Jahr gültig. Wenn Sie jedoch die Gültigkeitsdauer des Zugriffstokens anpassen möchten, können Sie die Methoden tokensExpireIn und refreshTokensExpireIn verwenden. Die beiden oben genannten Methoden müssen auch in der AuthServiceProvider-Methode von boot aufgerufen werden: 

/**
 * 注册认证 / 授权服务
 *
 * @return void
 */
 public function boot(){
     $this->registerPolicies();    
     Passport::routes();    
     Passport::tokensExpireIn(now()->addDays(15));    
     Passport::refreshTokensExpireIn(now()->addDays(30));
   }

Override the default model

Sie können das von Passport verwendete Modell bis Passport frei erweitern Das benutzerdefinierte Klassenmodell überschreibt das Standardmodell: 

use App\Models\Passport\Client;
use App\Models\Passport\AuthCode;
use App\Models\Passport\TokenModel;
use App\Models\Passport\PersonalAccessClient;
/**
 * 注册认证 / 授权服务
 *
 * @return void
 */
 public function boot(){
     $this->registerPolicies();    
     Passport::routes();    
     Passport::useClientModel(Client::class);    
     Passport::useTokenModel(TokenModel::class);    
     Passport::useAuthCodeModel(AuthCode::class);    
     Passport::usePersonalAccessClientModel(PersonalAccessClient::class);
    }

Zugriffstoken ausgeben

Entwickler, die mit OAuth2 vertraut sind, müssen wissen, dass ein wesentlicher Bestandteil von OAuth2 der Autorisierungscode ist. Bei Verwendung eines Autorisierungscodes leitet die Clientanwendung den Benutzer zu Ihrem Server weiter und genehmigt oder lehnt die Anforderung eines Zugriffstokens an den Client ab.

Management Client

Zuerst muss der Entwickler die Anwendung erstellen, die mit der Anwendungs-API interagieren muss Registrieren Sie Ihre Anwendung, indem Sie einen „Client“ erstellen. Im Allgemeinen umfasst dies die Angabe des Namens der Anwendung des Benutzers und einer URL, zu der die Anwendung umleiten kann, nachdem der Benutzer seine Autorisierungsanfrage genehmigt hat.

Der passport:client-Befehl

Der einfachste Weg, einen Client zu erstellen, ist die Verwendung des Artisan-Befehls passport:client. Mit diesem Befehl können Sie Ihren eigenen Client erstellen , zum Testen Ihrer OAuth2-Funktionalität verwenden. Wenn Sie den Befehl client ausführen, fordert Passport Sie zur Eingabe von Informationen über den Client auf und gibt Ihnen schließlich die ID und das Geheimnis des Clients bekannt: 

php artisan passport:client

URLs umleiten

Wann Es gibt mehrere Whitelists für Weiterleitungs-URLs. Sie können die URL an der Eingabeaufforderung passport:client eingeben Wenn angegeben, verwenden Sie eine Komma-Trennung, um Folgendes anzugeben:

http://example.com/callback,http://examplefoo.com/callback

{note} Jede URL, die Kommas enthält, muss codiert werden.

JSON-API

Da Ihre Benutzer den Client-Befehl nicht verwenden können, stellt Passport eine JSON-API bereit, die zum Erstellen von „Clients“ verwendet werden kann. Auf diese Weise müssen Sie keine Zeit damit verbringen, Controller zum Erstellen, Aktualisieren und Löschen von Clients zu schreiben.

Sie müssen jedoch noch eine Front-End-Schnittstelle basierend auf der JSON-API von Passport entwickeln, um Ihren Benutzern ein Client-Verwaltungspanel bereitzustellen. Nachfolgend listen wir alle APIs auf, die zur Verwaltung von Clients verwendet werden. Der Einfachheit halber verwenden wir Axios, um das Senden von HTTP-Anfragen an den Port zu demonstrieren.

Diese JSON-API ist durch zwei Middlewares geschützt, web und auth, sodass sie nur von der Anwendung und nicht von außen aufgerufen werden kann.

{Tipp} Wenn Sie nicht die gesamte Client-Management-Frontend-Schnittstelle selbst implementieren möchten, können Sie Schnell mit dem Frontend beginnen verwenden, um eine zu erstellen Voll funktionsfähige Frontend-Schnittstelle in wenigen Minuten.

GET /oauth/clients

Diese Route gibt alle Clients des authentifizierten Benutzers zurück. Der Hauptzweck besteht darin, die Clients aller Benutzer aufzulisten, damit sie sie bearbeiten oder löschen können: 

axios.get('/oauth/clients')
    .then(response => {
        console.log(response.data); 
      });

POST /oauth/clients

Diese Route wird verwendet, um neue Kunden zu erstellen. Es werden zwei Parameter benötigt: der Name des Clients name und die URL des Rückrufs nach der Autorisierung redirect. Nach der Genehmigung oder Ablehnung der Autorisierungsanfrage wird der Benutzer zu dem Link weitergeleitet, der durch den Parameter redirect bereitgestellt wird.

Wenn der Client erstellt wird, werden die ID und der Schlüssel des Clients zurückgegeben. Mit diesen beiden Werten kann der Client ein Zugriffstoken von Ihrem Autorisierungsdienst anfordern. Diese Route gibt eine neue Client-Instanz zurück: 

const data = {
    name: 'Client Name',
    redirect: 'http://example.com/callback'};
    axios.post('/oauth/clients', data)
        .then(response => {
                console.log(response.data); 
           })
         .catch (response => {
                // 在response里列出错误详情...    
             });

PUT /oauth/clients/{client-id}

Diese Route wird zum Aktualisieren von Client-Informationen verwendet. Es sind zwei Parameter erforderlich: der Name des Clients name und die URL des Rückrufs nach der Autorisierung redirect. Nach Genehmigung oder Ablehnung der Autorisierungsanfrage wird der Benutzer redirect zu diesem Link weitergeleitet. Diese Route gibt die aktualisierte Client-Instanz zurück: 

const data = {
    name: 'New Client Name',
    redirect: 'http://example.com/callback'};
    axios.put('/oauth/clients/' + clientId, data)
        .then(response => {
                console.log(response.data);    
              })    
         .catch (response => { 
                // 在response里列出错误详情...    
            });

DELETE /oauth/clients/{client-id}

Diese Route wird zum Löschen des Clients verwendet (Kunde): 

axios.delete('/oauth/clients/' + clientId)
    .then(response => {  
          //   
       });

Token anfordern

Umleitung bei Autorisierung

Nachdem der Client erstellt wurde, verwendet der Entwickler die ID dieses Clients und Schlüssel zum Anfordern von Autorisierungscodes und Zugriffstokens von der Anwendung. Zuerst sendet der Benutzer, der auf die Anwendung zugreift, eine Umleitungsanforderung an die Route /oauth/authorize Ihrer Anwendung. Das Beispiel sieht wie folgt aus: 

Route::get('/redirect', function () {
    $query = http_build_query([ 
           'client_id' => 'client-id',        
           'redirect_uri' => 'http://example.com/callback',        
           'response_type' => 'code',        
           'scope' => '',    
        ]);    
      return redirect('http://your-app.com/oauth/authorize?'.$query);
    });

{tip} Beachten Sie, dass die Route /oauth/authorize bereits vorhanden ist die Passport::routes Methodendefinition. Sie müssen diese Route nicht manuell definieren.

Anfrage genehmigen

Wenn eine Autorisierungsanfrage eingeht, zeigt Passport dem Benutzer automatisch eine Vorlagenseite an, die es dem Benutzer ermöglicht, die Autorisierung zu genehmigen oder abzulehnen Anfrage. Wenn der Benutzer die Anfrage genehmigt, wird er zurück zu dem von der zugreifenden Anwendung angegebenen redirect_uri weitergeleitet. redirect_uri muss genau mit dem Link redirect übereinstimmen, der beim Erstellen des Clients angegeben wurde.

Wenn Sie die Autorisierungsbestätigungsseite anpassen möchten, können Sie den Artisan-Befehl vendor:publish verwenden, um die Passport-Ansicht zu veröffentlichen. Die veröffentlichten Ansichtsdateien werden in resources/views/vendor/passport gespeichert: 

php artisan vendor:publish --tag=passport-views

Autorisierungscode in Zugriffstoken umwandeln

Nachdem der Benutzer die Autorisierungsanfrage genehmigt hat, wird er zurück zur verbundenen Anwendung weitergeleitet. Die zugreifende Anwendung sollte dann über eine POST-Anfrage ein Zugriffstoken von Ihrer Anwendung anfordern. Die Anfrage sollte den Autorisierungscode enthalten, der von der Anwendung ausgegeben wird, wenn der Benutzer die Autorisierungsanfrage genehmigt. Im folgenden Beispiel verwenden wir die HTTP-Bibliothek Guzzle, um diese POST-Anfrage zu implementieren: 

Route::get('/callback', function (Request $request) {
    $http = new GuzzleHttp\Client;    
    $response = $http->post('http://your-app.com/oauth/token', [  
          'form_params' => [      
                'grant_type' => 'authorization_code',            
                'client_id' => 'client-id',            
                'client_secret' => 'client-secret',            
                'redirect_uri' => 'http://example.com/callback',            
                'code' => $request->code,        
               ],    
            ]);    
      return json_decode((string) $response->getBody(), true);
   });

Route /oauth/token Die zurückgegebene JSON-Antwort enthält die Attribute access_token , refresh_token und expires_in . expires_in Das Attribut enthält die Gültigkeitsdauer des Zugriffstokens in Sekunden.

{tip} Wie die /oauth/authorize-Route wird auch die /oauth/token-Route in der Passport::routes-Methode definiert und Sie müssen sie nicht manuell definieren. Standardmäßig verwendet diese Route die Einstellungen der Middleware „ThrottleRequests“ zur Drosselung.

Aktualisierungstoken

Wenn Ihre Anwendung ein kurzlebiges Zugriffstoken ausgibt, wird der Benutzer dies benötigen um ihr Zugriffstoken über das Aktualisierungstoken zu aktualisieren, das ihnen bei der Ausstellung des Zugriffstokens bereitgestellt wurde. Im folgenden Beispiel verwenden wir die HTTP-Bibliothek Guzzle, um das Token zu aktualisieren: Die Route 

$http = new GuzzleHttp\Client;
$response = $http->post('http://your-app.com/oauth/token', [ 
   'form_params' => [  
         'grant_type' => 'refresh_token',        
         'refresh_token' => 'the-refresh-token',        
         'client_id' => 'client-id',        
         'client_secret' => 'client-secret',        
         'scope' => '',    
        ],]);
   return json_decode((string) $response->getBody(), true);

/oauth/token gibt eine JSON-Antwort zurück, die die Attribute access_token , refresh_token und expires_in enthält. expires_in Das Attribut enthält die Gültigkeitszeit des Zugriffstokens in Sekunden.

Passwort-Autorisierungs-Token

Der OAuth2-Passwort-Autorisierungsmechanismus ermöglicht es Ihren eigenen Clients (z. B. mobilen Anwendungen), ein zu erhalten Zugriffstoken mit Ihrer E-Mail-Adresse oder Ihrem Benutzernamen und Passwort. Auf diese Weise können Sie Zugriffstokens sicher an Ihre eigenen Clients ausstellen, ohne den gesamten OAuth2-Autorisierungscode-Umleitungsprozess durchlaufen zu müssen

Erstellen Sie ein Passwort-Autorisierungs-Client

Bevor die Anwendung Token über den Passwort-Autorisierungsmechanismus ausgibt, in Fügen Sie den Parameter passport:client nach dem Befehl --password hinzu, um einen kennwortautorisierten Client zu erstellen. Wenn Sie den Befehl passport:install bereits ausgeführt haben, müssen Sie diesen Befehl nicht erneut ausführen: 

php artisan passport:client --password

Token anfordern

Sobald Sie einen Client mit Passwortschutz erstellt haben, können Sie ein Zugriffstoken erhalten, indem Sie mit der E-Mail-Adresse und dem Passwort des Benutzers eine /oauth/token Anfrage an die Route POST stellen. Und die Route ist bereits mit der Methode Passport::routes registriert, sodass keine manuelle Definition erforderlich ist. Wenn die Anfrage erfolgreich ist, erhalten Sie ein access_token und refresh_token in der vom Server zurückgegebenen JSON-Antwort: 

$http = new GuzzleHttp\Client;
$response = $http->post('http://your-app.com/oauth/token', [
    'form_params' => [   
         'grant_type' => 'password',        
         'client_id' => 'client-id',        
         'client_secret' => 'client-secret',        
         'username' => 'taylor@laravel.com',        
         'password' => 'my-password',        
         'scope' => '',    
         ],]);
   return json_decode((string) $response->getBody(), true);

{tip} Standardmäßig ist das Zugriffstoken lange gültig Zeit. Sie können die Gültigkeitsdauer des Zugriffstokens nach Bedarf konfigurieren.

Alle Bereiche anfordern

Bei Verwendung des Kennwortautorisierungsmechanismus können Sie den Bereichsparameter per anfordern Anfordern*, alle von der Anwendung unterstützten Tokenbereiche zu autorisieren. Wenn Ihre Anfrage einen Parameter mit dem Gültigkeitsbereich * enthält, gibt die Methode can auf der Tokeninstanz immer true zurück. Die Autorisierung dieses Bereichs kann nur Token zugewiesen werden, die bei Verwendung der password-Autorisierung ausgegeben werden: 

$response = $http->post('http://your-app.com/oauth/token', [
    'form_params' => [   
         'grant_type' => 'password',        
         'client_id' => 'client-id',        
         'client_secret' => 'client-secret',        
         'username' => 'taylor@laravel.com',        
         'password' => 'my-password',        
         'scope' => '*',
        ],
      ]);

Benutzerdefinierter Benutzername-Abschnitt

Bei der Passwortautorisierung verwendet Passport standardmäßig email als „Benutzernamen“. Sie können das Benutzernamensfeld jedoch anpassen, indem Sie eine findForPassport-Methode für das Modell definieren: 

<?php
    namespace App;
    use Laravel\Passport\HasApiTokens;
    use Illuminate\Notifications\Notifiable;
    use Illuminate\Foundation\Auth\User as Authenticatable;
    class User extends Authenticatable{  
      use HasApiTokens, Notifiable;    
      /**
     * 通过用户名找到对应的用户信息
     *
     * @param  string  $username
     * @return \App\User
     */   
      public function findForPassport($username) 
         {    
             return $this->where('username', $username)->first(); 
         }
      }

Implizites Autorisierungstoken

Die implizite Autorisierung ähnelt der Autorisierungscode-Autorisierung, gibt jedoch nur das Token an den Client zurück, ohne den Autorisierungscode auszutauschen. Diese Autorisierung wird am häufigsten für JavaScript oder mobile Anwendungen verwendet, die Client-Anmeldeinformationen nicht sicher speichern können. Aktivieren Sie diese Autorisierung, indem Sie die AuthServiceProvider-Methode in enableImplicitGrant aufrufen: 

/**
 * 注册认证 / 授权服务
 *
 * @return void
 */
 public function boot(){
     $this->registerPolicies();    
     Passport::routes();    
     Passport::enableImplicitGrant();
    }

Nach dem Aufruf der oben genannten Methode zum Aktivieren der Autorisierung können Entwickler ihre Client-ID verwenden, um ein Zugriffstoken von der Anwendung anzufordern. Die verbundene Anwendung sollte eine Umleitungsanforderung an die /oauth/authorize-Route Ihrer Anwendung stellen, wie unten gezeigt: 

Route::get('/redirect', function () {
    $query = http_build_query([   
         'client_id' => 'client-id',        
         'redirect_uri' => 'http://example.com/callback',        
         'response_type' => 'token',        
         'scope' => '',    
         ]);    
    return redirect('http://your-app.com/oauth/authorize?'.$query);
  });

{tip} Beachten Sie, dass die /oauth/authorize-Route bereits in der Passport::routes-Methode definiert ist in , sodass diese Route nicht erneut manuell definiert werden muss.

Client Credential Grant Token

Client Credential Grant eignet sich für die Maschine-zu-Maschine-Authentifizierung. Mit dieser Berechtigung können Sie beispielsweise Wartungsaufgaben über die API durchführen.

Vor der Client-Anmeldeinformationsautorisierung müssen Sie einen Client-Anmeldeinformations-Autorisierungsclient erstellen. Sie können den passport:client-Parameter des --client-Befehls verwenden, um ihn zu erstellen: 

php artisan passport:client --client

Weiter, Zu verwenden Für diese Berechtigung müssen Sie zunächst das app/Http/Kernel.php in $routeMiddleware festlegen Fügen Sie der Variablen eine neue Middleware hinzu: 

use Laravel\Passport\Http\Middleware\CheckClientCredentials;
protected $routeMiddleware = [
    'client' => CheckClientCredentials::class,
  ];

Hängen Sie dann diese Middleware an die Route an: 

Route::get('/orders', function (Request $request) {
    ...
 })->middleware('client');

Wenn Sie den Zugriff auf die Route auf einen bestimmten Bereich beschränken möchten, können Sie < 🎜 hinzufügen > Geben Sie eine durch Kommas getrennte Liste der erforderlichen Bereiche an, wenn die Middleware an eine Route angehängt ist: client

Route::get('/orders', function (Request $request) {
    ...
})->middleware('client:check-status,your-scope');

Holen Sie sich das Token

, indem Sie

aufrufen Die Schnittstelle fordert den Erhalt des Tokens an: oauth/token

$guzzle = new GuzzleHttp\Client;
$response = $guzzle->post('http://your-app.com/oauth/token', [ 
   'form_params' => [ 
          'grant_type' => 'client_credentials',        
          'client_id' => 'client-id',        
          'client_secret' => 'client-secret',        
          'scope' => 'your-scope',    
         ],]);
   return json_decode((string) $response->getBody(), true)['access_token'];

Persönliches Zugriffstoken

Manchmal muss der Benutzer dies tun Stellen Sie sich selbst ein Zugriffstoken aus, ohne den herkömmlichen Prozess zur Autorisierungscode-Umleitung durchlaufen zu müssen. Wenn Sie Benutzern erlauben, über die Benutzeroberfläche der Anwendung Token für sich selbst auszustellen, kann dies dazu beitragen, dass Benutzer Ihre API erleben, oder es kann als einfachere Möglichkeit zum Ausstellen von Zugriffstokens verwendet werden.

{note} Das persönliche Zugriffstoken ist dauerhaft gültig und sein Lebenszyklus wird nicht geändert, auch wenn die Methoden

und tokensExpireIn verwendet werden. refreshTokensExpireIn

Erstellen Sie einen Personal Access Client

Bevor Ihre Anwendung ein Personal Access Token ausgibt, müssen Sie dies tun Bringen Sie den Parameter

nach dem Befehl passport:client mit, um den entsprechenden Client zu erstellen. Wenn Sie den Befehl --personal bereits ausgeführt haben, müssen Sie diesen Befehl nicht erneut ausführen: passport:install

php artisan passport:client --personal

Wenn Sie bereits einen Personal Access-Client erstellt haben, können Sie dies tun, indem Sie den Befehl

aufrufen Methoden zum Aktivieren: AuthServiceProvider

/**
 * 注册认证 / 授权服务
 *
 * @return void
 */
 public function boot(){ 
    $this->registerPolicies();    
    Passport::routes();    
    Passport::personalAccessClientId('client-id');
  }
personalAccessClientId

Persönliche Zugriffstoken verwalten

Nachdem Sie den Personal Access-Client erstellt haben, können Sie <🎜 verwenden > Methode für eine Modellinstanz zum Ausstellen eines Tokens für einen bestimmten Benutzer. Die

-Methode akzeptiert den Namen des Tokens als erstes Argument und ein optionales

scopeUser-Array als zweites Argument: createToken

$user = App\User::find(1);
// 创建没有作用域的访问令牌...
$token = $user->createToken('Token Name')->accessToken;
// 创建有作用域的访问令牌...
$token = $user->createToken('My Token', ['place-orders'])->accessToken;
createToken

JSON-API

Passport verfügt außerdem über eine JSON-API zur Verwaltung persönlicher Zugriffstoken, die Sie mit Ihrem eigenen Frontend koppeln können, um Benutzern ein Dashboard zur Verwaltung persönlicher Zugriffstoken bereitzustellen. Nachfolgend beschreiben wir alle API-Schnittstellen zur Verwaltung persönlicher Zugriffstokens. Der Einfachheit halber verwenden wir Axios, um das Senden von HTTP-Anfragen an die API-Schnittstelle zu demonstrieren. Die

JSON-API ist durch die web- und auth-Middleware geschützt und kann daher nur aus Ihrer eigenen Anwendung aufgerufen werden. Es kann nicht von externen Quellen aufgerufen werden.

{Tipp} Wenn Sie keine eigene Front-End-Schnittstelle für die Verwaltung persönlicher Zugriffstoken implementieren möchten, können Sie zum Erstellen dem Schnellstart mit Front-End folgen in wenigen Minuten eine voll funktionsfähige Frontend-Schnittstelle.

GET /oauth/scopes

Diese Route gibt alle in der Anwendung definierten Bereiche zurück. Mit dieser Route können Sie die Bereiche auflisten, die ein Benutzer möglicherweise persönlichen Zugriffstokens zugewiesen hat: 

axios.get('/oauth/scopes')
    .then(response => {
        console.log(response.data);    
      });

GET /oauth/personal-access-tokens

Diese Route gibt alle von erstellten persönlichen Zugriffe zurück das authentifizierte Benutzer-Token. Dies wird hauptsächlich verwendet, um die Token aller Benutzer aufzulisten, damit sie sie bearbeiten oder löschen können: 

axios.get('/oauth/personal-access-tokens')
    .then(response => {
        console.log(response.data);   
      });

POST /oauth/personal-access-tokens

Diese Route wird verwendet, um neue Zugriffstoken für Einzelpersonen zu erstellen . Es sind zwei Daten erforderlich: das name des Tokens und scpoe:

const data = {
    name: 'Token Name',
    scopes: []};
    axios.post('/oauth/personal-access-tokens', data)
        .then(response => {
            console.log(response.data.accessToken);    
        })    
        .catch (response => { 
               // 列出响应中错误...    
        });

DELETE /oauth/personal-access-tokens/{token-id}

Über diesen Weg können persönliche Zugriffstoken gelöscht werden: 

axios.delete('/oauth/personal-access-tokens/' + tokenId);

Routenschutz

über Middleware

Passport Enthält einen Authentifizierungsschutzmechanismus, der das in der Anfrage übergebene Zugriffstoken überprüfen kann. Nachdem Sie den Watcher von api für die Verwendung des passport-Treibers konfiguriert haben, geben Sie einfach die auth:api-Middleware auf jeder Route an, die ein gültiges Zugriffstoken erfordert: 

Route::get('/user', function () {
    //
 })->middleware('auth:api');

Zugriffstoken übergeben

beim Anruf Beim Routing unter Passport-Schutz muss die API-Anwendung, auf die zugegriffen wird, das Zugriffstoken als Bearer-Token im Anforderungsheader Authorization einfügen. Zum Beispiel bei Verwendung der Guzzle-HTTP-Bibliothek: 

$response = $client->request('GET', '/api/user', [
    'headers' => [  
          'Accept' => 'application/json',        
          'Authorization' => 'Bearer '.$accessToken,    
         ],
      ]);

Token Scope

Scope ermöglicht es API-Clients, bestimmte Berechtigungen anzufordern, wenn sie eine Kontoautorisierung anfordern. Wenn Sie beispielsweise eine E-Commerce-Anwendung erstellen, benötigen nicht alle API-Anwendungen, die eine Verbindung dazu herstellen, die Möglichkeit, Bestellungen aufzugeben. Sie können zulassen, dass verbundene API-Anwendungen nur für den Zugriff auf den Versandstatus der Bestellung autorisiert werden. Mit anderen Worten: Durch die Festlegung des Gültigkeitsbereichs können Benutzer einer Anwendung die Aktionen einschränken, die Anwendungen von Drittanbietern ausführen können.

Definieren Sie den Umfang

Sie können die AuthServiceProvider-Methode innerhalb der boot-Methode von <🎜 verwenden > um den Umfang der API zu definieren. Die Passport::tokensCan-Methode akzeptiert ein Array, das den Bereichsnamen und die Beschreibung als Parameter enthält. Die Umfangsbeschreibung wird dem Benutzer direkt auf der Autorisierungsbestätigungsseite angezeigt. Sie können sie als alles definieren, was Sie benötigen: tokensCan

use Laravel\Passport\Passport;
Passport::tokensCan([
    'place-orders' => 'Place orders',    
    'check-status' => 'Check order status',
  ]);

Standardbereich

Wenn der Client keinen bestimmten Bereich anfordert, können Sie den Bereich in

festlegen Verwenden Sie die Methode AuthServiceProvider, um den Standardbereich zu definieren. boot

use Laravel\Passport\Passport;Passport::setDefaultScope([
    'check-status',    
    'place-orders',
  ]);
Passport::setDefaultScope

Bereich dem Token zuweisen

Autorisierungscode anfordern

Beim Anfordern eines Zugriffstokens mithilfe eines Autorisierungscodes muss die verbundene Anwendung

sein Der Parameter gibt den erforderlichen Umfang an.

Wenn der Parameter mehrere Bereiche enthält, verwenden Sie Leerzeichen, um die Namen zu trennen: scope

Route::get('/redirect', function () {
    $query = http_build_query([  
          'client_id' => 'client-id',        
          'redirect_uri' => 'http://example.com/callback',        
          'response_type' => 'code',        
          'scope' => 'place-orders check-status',   
        ]);    
 return redirect('http://your-app.com/oauth/authorize?'.$query);});
scope

Persönliche Zugriffstokens verteilen

Verwenden Sie das

des

-Modells Bei der Ausgabe eines persönlichen Zugriffstokens können Sie das Array des erforderlichen Bereichs als zweiten Parameter an diese Methode übergeben: User

$token = $user->createToken('My Token', ['place-orders'])->accessToken;
createToken

Check Bereich

Passport enthält zwei Middlewares, mit denen überprüft werden kann, ob eingehende Anforderungen ein Token für den Zugriff auf den angegebenen Bereich enthalten. Vor der Verwendung müssen Sie die folgende Middleware zum

-Attribut der

-Datei hinzufügen: app/Http/Kernel.php

'scopes' => \Laravel\Passport\Http\Middleware\CheckScopes::class,
'scope' => \Laravel\Passport\Http\Middleware\CheckForAnyScope::class,
$routeMiddleware

Alle Bereiche prüfen

Routing kann <🎜 verwenden > Middleware, um zu prüfen, ob in der aktuellen Anfrage alle

angegebenen

enthalten sind Geltungsbereich: scopes

Route::get('/orders', function () { 
   // Access token has both "check-status" and "place-orders" scopes...
   })->middleware('scopes:check-status,place-orders');

Überprüfung eines beliebigen Geltungsbereichs
Router können die

-Middleware verwenden, um zu prüfen, ob die aktuelle Anfrage die angegebene

irgendeine

Rollendomäne hat : scope

Route::get('/orders', function () {
    // 访问令牌具有 "check-status" 或 "place-orders" 作用域...
  })->middleware('scope:check-status,place-orders');

Überprüfen Sie den Bereich auf der Token-Instanz

Auch wenn die Anfrage mit der Zugriffstoken-Verifizierung von der Anwendung authentifiziert wurde, können Sie weiterhin die aktuelle Autorisierung User auf der Instanz tokenCan verwenden Methode zur Überprüfung, ob das Token den angegebenen Bereich besitzt: 

use Illuminate\Http\Request;
Route::get('/orders', function (Request $request) {
    if ($request->user()->tokenCan('place-orders')) { 
           //    
         }
     });

Append Scope Method

scopeIds Die Methode gibt ein Array aller definierten IDs/Namen zurück: The Die Methode 

Laravel\Passport\Passport::scopeIds();

scopes gibt ein Array zurück, das alle definierten Bereiche enthält LaravelPassportScope Instanz: 

Laravel\Passport\Passport::scopes();

scopesFor Methode gibt ein Array von LaravelPassportScope Instanzen zurück, die mit der angegebenen ID/dem angegebenen Namen übereinstimmen: 

Laravel\Passport\Passport::scopesFor(['place-orders', 'check-status']);

Sie können hasScope verwenden Methode, um festzustellen, ob ein bestimmter Bereich definiert ist: 

Laravel\Passport\Passport::hasScope('place-orders');

Verwenden von JavaScript für den Zugriff auf die API

Beim Erstellen des API: Wenn Sie über JavaScript-Anwendungen auf Ihre eigene API zugreifen können, wird der Entwicklungsprozess erheblich vereinfacht. Dieser Ansatz zur API-Entwicklung ermöglicht es Ihnen, die API Ihrer eigenen Anwendung und die gemeinsam genutzten APIs anderer zu verwenden. Ihre Web-App, mobile App, Apps von Drittanbietern und alle SDKs, die Sie möglicherweise auf verschiedenen Paketmanagern veröffentlichen, verwenden wahrscheinlich dieselbe API.

Wenn Sie eine API aus einer JavaScript-Anwendung verwenden möchten, müssen Sie normalerweise manuell ein Zugriffstoken senden und es an die Anwendung übergeben. Passport verfügt jedoch über eine Middleware, die dieses Problem behebt. Fügen Sie einfach die CreateFreshApiToken-Middleware zur app/Http/Kernel.php-Middleware-Gruppe in der web-Datei hinzu: 

'web' => [ 
   // 其他中间件...
    \Laravel\Passport\Http\Middleware\CreateFreshApiToken::class,
   ],

{note} Sie sollten sicherstellen, dass sich CreateFreshApiToken in Ihrem Middleware-Stack Middleware <🎜 befindet > Middleware wurde zuvor aufgeführt. EncryptCookies

Diese Passport-Middleware fügt allen Ihren ausgehenden Anfragen ein

-Cookie hinzu. Dieses Cookie enthält ein verschlüsseltes JWT, das Passport zur Authentifizierung von API-Anfragen von JavaScript-Anwendungen verwendet. An dieser Stelle können Sie Anfragen an die API Ihrer Anwendung stellen, ohne das Zugriffstoken explizit zu übergeben: laravel_token

axios.get('/api/user')
    .then(response => {
        console.log(response.data);    
     });

Benutzerdefinierter Cookie-Name

Bei Bedarf können Sie das <🎜 verwenden >-Methode in der

-Methode, um den Namen des AuthServiceProvider-Cookies anzupassen. boot

/**
 * 注册认证 / 授权服务
 *
 * @return void
 */
 public function boot(){
     $this->registerPolicies();    
     Passport::routes();    
     Passport::cookie('custom_name');
   }
Passport::cookielaravel_token

CSRF-Schutz
Bei Verwendung dieser Autorisierungsmethode veranlasst das Standard-JavaScript-Gerüst von Laravel, dass Axios die Anforderungsheader

und

sendet. Darüber hinaus müssen Sie sicherstellen, dass das CSRF-Token im HTML-Meta-Tag enthalten ist: 

// In your application layout...
<meta name="csrf-token" content="{{ csrf_token() }}">
// Laravel's JavaScript scaffolding...
window.axios.defaults.headers.common = {
    'X-Requested-With': 'XMLHttpRequest',
   };
X-CSRF-TOKENX-Requested-With

Ereignisse

Passport löst Ereignisse aus, wenn Zugriffstoken und Aktualisierungstoken ausgestellt werden. Sie können Listener für diese Ereignisse im EventServiceProvider Ihrer Anwendung anhängen und andere Token in den Listenern widerrufen oder ändern: 

/**
 * 应用程序事件监听映射
 *
 * @var array
 */
 protected $listen = [
     'Laravel\Passport\Events\AccessTokenCreated' => [
             'App\Listeners\RevokeOldTokens', 
               ],    
      'Laravel\Passport\Events\RefreshTokenCreated' => [ 
             'App\Listeners\PruneOldTokens',   
             ],
         ];

Test

ReisepassactingAs Die Methode kann den aktuell authentifizierten Benutzer und seinen Bereich angeben. Der erste Parameter der actingAs-Methode ist die Benutzerinstanz und der zweite Parameter ist das Benutzer-Token-Bereichsarray: 

use App\User;
use Laravel\Passport\Passport;
public function testServerCreation(){
    Passport::actingAs(  
          factory(User::class)->create(),   
               ['create-servers']  
             );    
         $response = $this->post('/api/create-server');    
        $response->assertStatus(201);
     }
Dieser Artikel wurde zuerst auf der Website LearnKu.com veröffentlicht.