OAuth 2.0 für Webserveranwendungen verwenden

PHP

Zum Ausführen der PHP-Codebeispiele in diesem Dokument ist Folgendes erforderlich:

• PHP 5.6 oder höher mit installierter Befehlszeile und JSON-Erweiterung
• Tool zur Abhängigkeitsverwaltung in Composer

• Google APIs-Clientbibliothek für PHP:

  composer require google/apiclient:^2.10

Python

Zum Ausführen der Python-Codebeispiele in diesem Dokument benötigen Sie Folgendes:

• Python 2.6 oder höher
• Das Paketverwaltungstool pip.
• Google APIs-Clientbibliothek für Python:

  pip install --upgrade google-api-python-client

• google-auth, google-auth-oauthlib und google-auth-httplib2 für die Nutzerautorisierung.

  pip install --upgrade google-auth google-auth-oauthlib google-auth-httplib2

• Das Python-Webanwendungs-Framework von Flask.

  pip install --upgrade flask

• Die HTTP-Bibliothek requests.

  pip install --upgrade requests

Ruby

Zum Ausführen der Ruby-Codebeispiele in diesem Dokument benötigen Sie Folgendes:

• Ruby 2.6 oder höher

• Die Google-Authentifizierungsbibliothek für Ruby:

  gem install googleauth

• Das Sinatra Ruby-Framework für Webanwendungen

  gem install sinatra

Node.js

Zum Ausführen der Node.js-Codebeispiele in diesem Dokument ist Folgendes erforderlich:

• Die Wartung „Langzeitsupport“, die aktive Version „Langzeitsupport“ oder der aktuelle Release von Node.js.

• Der Node.js-Client der Google APIs:

  npm install googleapis crypto express express-session

HTTP/REST

Sie müssen keine Bibliotheken installieren, um OAuth 2.0 direkt aufrufen zu können. Endpunkten.

PHP

Das folgende Code-Snippet erstellt ein Google\Client()-Objekt, das die -Parameter in der Autorisierungsanfrage.

Das Objekt verwendet Informationen aus der Datei client_secret.json, um Ihr . (Weitere Informationen finden Sie unter Anmeldedaten erstellen. dieser Datei.) Das Objekt identifiziert auch die Bereiche, die Ihre Anwendung Berechtigungen anfordert für den Zugriff und die URL zum Authentifizierungsendpunkt Ihrer Anwendung, der die Antwort von OAuth 2.0-Server von Google Schließlich legt der Code die optionalen access_type- und include_granted_scopes-Parameter.

So fordern Sie beispielsweise Offlinezugriff an, um die YouTube-Daten eines Nutzers abzurufen:

$client = new Google\Client();

// Required, call the setAuthConfig function to load authorization credentials from
// client_secret.json file.
$client->setAuthConfig('client_secret.json');

// Required, to set the scope value, call the addScope function
$client->addScope(Google_Service_YouTube::YOUTUBE_FORCE_SSL);

// Required, call the setRedirectUri function to specify a valid redirect URI for the
// provided client_id
$client->setRedirectUri('http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php');

// Recommended, offline access will give you both an access and refresh token so that
// your app can refresh the access token without user interaction.
$client->setAccessType('offline');

// Recommended, call the setState function. Using a state value can increase your assurance that
// an incoming connection is the result of an authentication request.
$client->setState($sample_passthrough_value);

// Optional, if your application knows which user is trying to authenticate, it can use this
// parameter to provide a hint to the Google Authentication Server.
$client->setLoginHint('hint@example.com');

// Optional, call the setPrompt function to set "consent" will prompt the user for consent
$client->setPrompt('consent');

// Optional, call the setIncludeGrantedScopes function with true to enable incremental
// authorization
$client->setIncludeGrantedScopes(true);

Python

Im folgenden Code-Snippet wird das Modul google-auth-oauthlib.flow verwendet, um in der Autorisierungsanfrage.

Der Code erstellt ein Flow-Objekt, das Ihre Anwendung mithilfe von aus der Datei client_secret.json, die Sie nach dem Herunterladen Anmeldedaten für die Autorisierung erstellen. Dieses Objekt identifiziert auch den Bereiche, für die Ihre Anwendung die Berechtigung anfordert, sowie die URL zum auth-Endpunkt, der die Antwort des OAuth 2.0-Servers von Google verarbeitet. Der Code legt die optionalen Parameter access_type und include_granted_scopes fest.

So fordern Sie beispielsweise Offlinezugriff an, um die YouTube-Daten eines Nutzers abzurufen:

import google.oauth2.credentials
import google_auth_oauthlib.flow

# Required, call the from_client_secrets_file method to retrieve the client ID from a
# client_secret.json file. The client ID (from that file) and access scopes are required. (You can
# also use the from_client_config method, which passes the client configuration as it originally
# appeared in a client secrets file but doesn't access the file itself.)
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
    'client_secret.json',
    scopes=['https://www.googleapis.com/auth/youtube.force-ssl'])

# Required, indicate where the API server will redirect the user after the user completes
# the authorization flow. The redirect URI is required. The value must exactly
# match one of the authorized redirect URIs for the OAuth 2.0 client, which you
# configured in the API Console. If this value doesn't match an authorized URI,
# you will get a 'redirect_uri_mismatch' error.
flow.redirect_uri = 'https://www.example.com/oauth2callback'

# Generate URL for request to Google's OAuth 2.0 server.
# Use kwargs to set optional request parameters.
authorization_url, state = flow.authorization_url(
    # Recommended, enable offline access so that you can refresh an access token without
    # re-prompting the user for permission. Recommended for web server apps.
    access_type='offline',
    # Optional, enable incremental authorization. Recommended as a best practice.
    include_granted_scopes='true',
    # Optional, if your application knows which user is trying to authenticate, it can use this
    # parameter to provide a hint to the Google Authentication Server.
    login_hint='hint@example.com',
    # Optional, set prompt to 'consent' will prompt the user for consent
    prompt='consent')

Ruby

Konfigurieren Sie mithilfe der von Ihnen erstellten Datei „client_secrets.json“ ein Clientobjekt in Ihrem . Beim Konfigurieren eines Clientobjekts geben Sie die Bereiche an, -Zugriff sowie die URL zum Authentifizierungsendpunkt Ihrer Anwendung, an dem die Antwort verarbeitet wird. vom OAuth 2.0-Server gesendet werden.

So fordern Sie beispielsweise Offlinezugriff an, um die YouTube-Daten eines Nutzers abzurufen:

require 'google/apis/youtube_v3'
require "googleauth"
require 'googleauth/stores/redis_token_store'

client_id = Google::Auth::ClientId.from_file('/path/to/client_secret.json')
scope = 'https://www.googleapis.com/auth/youtube.force-ssl'
token_store = Google::Auth::Stores::RedisTokenStore.new(redis: Redis.new)
authorizer = Google::Auth::WebUserAuthorizer.new(client_id, scope, token_store, '/oauth2callback')

Ihre Anwendung verwendet das Clientobjekt, um OAuth 2.0-Vorgänge auszuführen, z. B. das Generieren von Autorisierungsanforderungs-URLs und Anwenden von Zugriffstokens auf HTTP-Anfragen

Node.js

Mit dem folgenden Code-Snippet wird ein google.auth.OAuth2-Objekt erstellt, das die -Parameter in der Autorisierungsanfrage.

Dieses Objekt verwendet Informationen aus Ihrer Datei client_secret.json, um Ihre Anwendung zu identifizieren. Bis Sie nach Berechtigungen zum Abrufen eines Zugriffstokens von einem Nutzer fragen, leiten Sie ihn auf eine Zustimmungsseite weiter. So erstellen Sie eine URL für die Einwilligungsseite:

const {google} = require('googleapis');
const crypto = require('crypto');
const express = require('express');
const session = require('express-session');

/**
 * To use OAuth2 authentication, we need access to a CLIENT_ID, CLIENT_SECRET, AND REDIRECT_URI
 * from the client_secret.json file. To get these credentials for your application, visit
 * https://console.cloud.google.com/apis/credentials.
 */
const oauth2Client = new google.auth.OAuth2(
  YOUR_CLIENT_ID,
  YOUR_CLIENT_SECRET,
  YOUR_REDIRECT_URL
);

// Access scopes for read-only Drive activity.
const scopes = [
  'https://www.googleapis.com/auth/drive.metadata.readonly'
];

// Generate a secure random state value.
const state = crypto.randomBytes(32).toString('hex');

// Store state in the session
req.session.state = state;

// Generate a url that asks permissions for the Drive activity scope
const authorizationUrl = oauth2Client.generateAuthUrl({
  // 'online' (default) or 'offline' (gets refresh_token)
  access_type: 'offline',
  /** Pass in the scopes array defined above.
    * Alternatively, if only one scope is needed, you can pass a scope URL as a string */
  scope: scopes,
  // Enable incremental authorization. Recommended as a best practice.
  include_granted_scopes: true,
  // Include the state parameter to reduce the risk of CSRF attacks.
  state: state
});

Wichtiger Hinweis: Der refresh_token wird nur beim ersten Autorisierung. Mehr Details <ph type="x-smartling-placeholder"></ph> hier.

HTTP/REST

Der OAuth 2.0-Endpunkt von Google befindet sich bei https://accounts.google.com/o/oauth2/v2/auth. Dieses Auf den Endpunkt kann nur über HTTPS zugegriffen werden. Einfache HTTP-Verbindungen werden abgelehnt.

PHP

1. Generieren Sie eine URL, um den Zugriff vom OAuth 2.0-Server von Google anzufordern:

   $auth_url = $client->createAuthUrl();

2. Leite den Nutzer zu $auth_url weiter:

   header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));

Python

In diesem Beispiel wird gezeigt, wie der Nutzer über das Flask-Web zur Autorisierungs-URL weitergeleitet wird Anwendungsframework:

return flask.redirect(authorization_url)

Ruby

1. Generieren Sie eine URL, um den Zugriff vom OAuth 2.0-Server von Google anzufordern:

   auth_uri = authorizer.get_authorization_url(login_hint: user_id, request: request)

2. Leite den Nutzer zu auth_uri weiter.

Node.js

1. Verwenden Sie die generierte URL authorizationUrl aus Schritt 1 generateAuthUrl, um den Zugriff vom OAuth 2.0-Server von Google anzufordern.
2. Leite den Nutzer zu authorizationUrl weiter.

   res.redirect(authorizationUrl);

HTTP/REST

Sample redirect to Google's authorization server

An example URL is shown below, with line breaks and spaces for readability. The URL requests access to a scope that permits access to retrieve the user's YouTube data. It uses incremental authorization (include_granted_scopes=true) to ensure that the new access token covers any scopes to which the user previously granted the application access. Several other parameters are also set in the example.

https://accounts.google.com/o/oauth2/v2/auth?
 scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fyoutube.force-ssl&
 access_type=offline&
 include_granted_scopes=true&
 response_type=code&
 state=state_parameter_passthrough_value&
 redirect_uri=http%3A%2F%2Flocalhost%2Foauth2callback&
 client_id=client_id

Nachdem Sie die Anfrage-URL erstellt haben, leiten Sie den Nutzer dorthin weiter.

PHP

Verwende die authenticate, um einen Autorisierungscode gegen ein Zugriffstoken auszutauschen :

$client->authenticate($_GET['code']);

Sie können das Zugriffstoken mit der Methode getAccessToken abrufen:

$access_token = $client->getAccessToken();

Python

Verwende auf deiner Callback-Seite die google-auth-Bibliothek, um die Autorisierung zu bestätigen Serverantwort. Verwenden Sie dann die Methode flow.fetch_token, um die Autorisierung auszutauschen. Code in dieser Antwort für ein Zugriffstoken:

state = flask.session['state']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
    'client_secret.json',
    scopes=['https://www.googleapis.com/auth/youtube.force-ssl'],
    state=state)
flow.redirect_uri = flask.url_for('oauth2callback', _external=True)

authorization_response = flask.request.url
flow.fetch_token(authorization_response=authorization_response)

# Store the credentials in the session.
# ACTION ITEM for developers:
#     Store user's access and refresh tokens in your data store if
#     incorporating this code into your real app.
credentials = flow.credentials
flask.session['credentials'] = {
    'token': credentials.token,
    'refresh_token': credentials.refresh_token,
    'token_uri': credentials.token_uri,
    'client_id': credentials.client_id,
    'client_secret': credentials.client_secret,
    'scopes': credentials.scopes}

Ruby

Verwende auf deiner Callback-Seite die googleauth-Bibliothek, um den Autorisierungsserver zu überprüfen Antwort. Verwenden Sie die Methode authorizer.handle_auth_callback_deferred, um den und kehren zu der URL zurück, die die Autorisierung ursprünglich angefordert hat. Dieses den Austausch des Codes hinauszögern, indem die Ergebnisse vorübergehend in der Sitzung des Nutzers zwischengespeichert werden.

  target_url = Google::Auth::WebUserAuthorizer.handle_auth_callback_deferred(request)
  redirect target_url

Node.js

Verwende die getToken, um einen Autorisierungscode gegen ein Zugriffstoken auszutauschen :

const url = require('url');

// Receive the callback from Google's OAuth 2.0 server.
app.get('/oauth2callback', async (req, res) => {
  let q = url.parse(req.url, true).query;

  if (q.error) { // An error response e.g. error=access_denied
    console.log('Error:' + q.error);
  } else if (q.state !== req.session.state) { //check state value
    console.log('State mismatch. Possible CSRF attack');
    res.end('State mismatch. Possible CSRF attack');
  } else { // Get access and refresh tokens (if access_type is offline)

    let { tokens } = await oauth2Client.getToken(q.code);
    oauth2Client.setCredentials(tokens);
});

HTTP/REST

Rufen Sie zum Austausch eines Autorisierungscodes gegen ein Zugriffstoken die Methode https://oauth2.googleapis.com/token und legen Sie die folgenden Parameter fest:

Das folgende Snippet zeigt eine Beispielanfrage:

POST /token HTTP/1.1
Host: oauth2.googleapis.com
Content-Type: application/x-www-form-urlencoded

code=4/P7q7W91a-oMsCeLvIaQm6bTrgtp7&
client_id=your_client_id&
client_secret=your_client_secret&
redirect_uri=https%3A//oauth2.example.com/code&
grant_type=authorization_code

Google reagiert auf diese Anfrage mit der Rückgabe eines JSON-Objekts, das einen kurzlebigen Zugriff enthält. und ein Aktualisierungstoken. Beachten Sie, dass das Aktualisierungstoken nur zurückgegeben wird, wenn Ihre Anwendung den access_type festgelegt hat. offline in der ursprünglichen Anfrage an die Autorisierungsserver.

Die Antwort umfasst die folgenden Felder:

Das folgende Snippet zeigt eine Beispielantwort:

{
  "access_token": "1/fFAGRNJru1FTz70BzhT3Zg",
  "expires_in": 3920,
  "token_type": "Bearer",
  "scope": "https://www.googleapis.com/auth/youtube.force-ssl",
  "refresh_token": "1//xEoDL4iW3cxlI7yDbSRFYNG01kVKM2C-259HOF2aQbI"
}

PHP

Verwenden Sie das Zugriffstoken, um Google APIs aufzurufen. Führen Sie dazu die folgenden Schritte aus:

1. Wenn Sie ein Zugriffstoken auf ein neues Google\Client-Objekt anwenden müssen, Wenn Sie beispielsweise das Zugriffstoken in einer Nutzersitzung gespeichert haben, verwenden Sie die Methode setAccessToken-Methode:

   $client->setAccessToken($access_token);

2. Erstellen Sie ein Dienstobjekt für die API, die Sie aufrufen möchten. Sie erstellen ein Dienstobjekt, indem Sie Bereitstellung eines autorisierten Google\Client-Objekts für den Konstruktor für die API die Sie anrufen möchten. So rufst du beispielsweise die YouTube Data API auf:

   $youtube = new Google_Service_YouTube($client);

3. Stellen Sie Anfragen an den API-Dienst mithilfe der Schnittstelle, die vom Dienstobjekt bereitgestellt wird. Um beispielsweise das YouTube Data API zu verwenden, um eine Liste von Liveübertragungen für den authentifizierten Nutzer abzurufen, Kanal des Nutzers:

   $broadcasts = $youtube->liveBroadcasts->listLiveBroadcasts('id,snippet', [ 'mine' => true ]);

Python

Nach Erhalt eines Zugriffstokens kann Ihre Anwendung dieses Token zur Autorisierung von API-Anfragen auf im Namen eines bestimmten Nutzerkontos oder Dienstkontos. Nutzerspezifische Anmeldedaten für die Autorisierung verwenden um ein Dienstobjekt für die aufzurufende API zu erstellen, und verwenden dieses Objekt dann, um autorisierten API-Anfragen an.

1. Erstellen Sie ein Dienstobjekt für die API, die Sie aufrufen möchten. Sie erstellen ein Dienstobjekt, indem Sie durch Aufrufen der build-Methode der googleapiclient.discovery-Bibliothek mit dem Name und Version der API sowie die Nutzeranmeldedaten: So rufst du beispielsweise Version 3 der YouTube Data API auf:

   from googleapiclient.discovery import build
   
   youtube = build('youtube', 'v3', credentials=credentials)

2. Stellen Sie Anfragen an den API-Dienst mithilfe der Schnittstelle, die vom Dienstobjekt bereitgestellt wird. Um beispielsweise das YouTube Data API zu verwenden, um eine Liste von Liveübertragungen für den authentifizierten Nutzer abzurufen, Kanal des Nutzers:

   broadcasts = youtube.liveBroadcasts().list(part='id,snippet', mine=True).execute()

Ruby

Nach Erhalt eines Zugriffstokens kann Ihre Anwendung dieses Token verwenden, um API-Anfragen an im Namen eines bestimmten Nutzerkontos oder Dienstkontos. Nutzerspezifische Anmeldedaten für die Autorisierung verwenden um ein Dienstobjekt für die aufzurufende API zu erstellen, und verwenden dieses Objekt dann, um autorisierten API-Anfragen an.

1. Erstellen Sie ein Dienstobjekt für die API, die Sie aufrufen möchten. So rufst du beispielsweise Version 3 der YouTube Data API auf:

   youtube = Google::Apis::YoutubeV3::YouTubeService.new

2. Legen Sie die Anmeldedaten für den Dienst fest:

   youtube.authorization = credentials

3. Stellen Sie Anfragen an den API-Dienst mithilfe der Benutzeroberfläche vom Dienstobjekt bereitgestellt. Um beispielsweise das YouTube Data API zu verwenden, um eine Liste von Liveübertragungen für den authentifizierten Nutzer abzurufen, Kanal des Nutzers:

   broadcasts = youtube.list_liveBroadcasts('id,snippet', mine: true)

Alternativ kann die Autorisierung für einzelne Methoden bereitgestellt werden, indem das Schlüssel/Wert-Paar options-Parameter einer Methode zu:

broadcasts = youtube.list_liveBroadcasts('id,snippet', mine: true)

Node.js

Nachdem Sie ein Zugriffstoken abgerufen und auf das OAuth2-Objekt festgelegt haben, verwenden Sie das Objekt zum Aufrufen von Google APIs. Ihre Anwendung kann dieses Token verwenden, um API-Anfragen im Namen von einem bestimmten Benutzer- oder Dienstkonto. Erstellen Sie ein Dienstobjekt für die API, die Sie aufrufen möchten.

const { google } = require('googleapis');

// Example of using Google Drive API to list filenames in user's Drive.
const drive = google.drive('v3');
drive.files.list({
  auth: oauth2Client,
  pageSize: 10,
  fields: 'nextPageToken, files(id, name)',
}, (err1, res1) => {
  if (err1) return console.log('The API returned an error: ' + err1);
  const files = res1.data.files;
  if (files.length) {
    console.log('Files:');
    files.map((file) => {
      console.log(`${file.name} (${file.id})`);
    });
  } else {
    console.log('No files found.');
  }
});

HTTP/REST

Nachdem Ihre Anwendung ein Zugriffstoken erhalten hat, können Sie mit diesem Token Aufrufe an eine Google API für eine bestimmte Nutzerkonto, wenn die von der API erforderlichen Zugriffsbereiche gewährt wurden. Fügen Sie dazu Das Zugriffstoken in einer Anfrage an die API durch Einfügen einer access_token-Abfrage oder einen Bearer-Wert für den Authorization-HTTP-Header. Wenn möglich, der HTTP-Header ist zu bevorzugen, da Abfragezeichenfolgen in Serverprotokollen in der Regel sichtbar sind. In den meisten können Sie Aufrufe von Google APIs mithilfe einer Clientbibliothek einrichten (z. B. YouTube Live Streaming API aufrufen.

Beachte, dass die YouTube Live Streaming API den Dienstkontovorgang nicht unterstützt. Da wir ist keine Möglichkeit, ein Dienstkonto mit einem YouTube-Konto zu verknüpfen, generiert den Fehler NoLinkedYouTubeAccount.

Sie können alle Google APIs ausprobieren und ihre Bereiche auf der OAuth 2.0 Playground.

Beispiele für HTTP GET

Ein Aufruf an die <ph type="x-smartling-placeholder"></ph> liveBroadcasts.list. (YouTube Live Streaming API) über das Authorization: Bearer-HTTP-Protokoll. könnte wie folgt aussehen. Beachten Sie, dass Sie Ihr eigenes Zugriffstoken angeben müssen:

GET /youtube/v3/liveBroadcasts?part=id%2Csnippet&mine=true HTTP/1.1
Host: www.googleapis.com
Authorization: Bearer access_token

Hier ist ein Aufruf derselben API für den authentifizierten Nutzer mithilfe der access_token Abfragestringparameter:

GET https://www.googleapis.com/youtube/v3/liveBroadcasts?access_token=access_token&part=id%2Csnippet&mine=true

Beispiele für curl

Sie können diese Befehle mit der curl-Befehlszeilenanwendung testen. Hier ist ein Beispiel mit HTTP-Header-Option (bevorzugt):

curl -H "Authorization: Bearer access_token" https://www.googleapis.com/youtube/v3/liveBroadcasts?part=id%2Csnippet&mine=true

Alternativ können Sie die Parameteroption für den Abfragestring verwenden:

curl https://www.googleapis.com/youtube/v3/liveBroadcasts?access_token=access_token&part=id%2Csnippet&mine=true

PHP

So führen Sie das Beispiel aus:

1. Fügen Sie im API Consoledie URL des lokalen Computers zum Liste mit Weiterleitungs-URLs. Fügen Sie beispielsweise http://localhost:8080 hinzu.
2. Erstellen Sie ein neues Verzeichnis und wechseln Sie zu diesem Verzeichnis. Beispiel:

   mkdir ~/php-oauth2-example
   cd ~/php-oauth2-example

3. Google API-Client installieren Bibliothek für PHP mit Composer verwenden:

   composer require google/apiclient:^2.10

4. Erstellen Sie die Dateien index.php und oauth2callback.php mit dem Inhalt. unten.
5. Führen Sie das Beispiel mit einem Webserver aus, der für PHP konfiguriert ist. Wenn Sie PHP 5.6 oder höher verwenden, können Sie den integrierten Test-Webserver von PHP verwenden:

   php -S localhost:8080 ~/php-oauth2-example

index.php

<?php
require_once __DIR__.'/vendor/autoload.php';

session_start();

$client = new Google\Client();
$client->setAuthConfig('client_secrets.json');
$client->addScope(Google_Service_YouTube::YOUTUBE_FORCE_SSL);

if (isset($_SESSION['access_token']) && $_SESSION['access_token']) {
  $client->setAccessToken($_SESSION['access_token']);
  $youtube = new Google_Service_YouTube($client);
  $broadcasts = $youtube->liveBroadcasts->listLiveBroadcasts('id,snippet', [ 'mine' => true ]);
  echo json_encode($broadcasts);
} else {
  $redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php';
  header('Location: ' . filter_var($redirect_uri, FILTER_SANITIZE_URL));
}

oauth2callback.php

<?php
require_once __DIR__.'/vendor/autoload.php';

session_start();

$client = new Google\Client();
$client->setAuthConfigFile('client_secrets.json');
$client->setRedirectUri('http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php');
$client->addScope(Google_Service_YouTube::YOUTUBE_FORCE_SSL);

if (! isset($_GET['code'])) {
  // Generate and set state value
  $state = bin2hex(random_bytes(16));
  $client->setState($state);
  $_SESSION['state'] = $state;

  $auth_url = $client->createAuthUrl();
  header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));
} else {
  // Check the state value
  if (!isset($_GET['state']) || $_GET['state'] !== $_SESSION['state']) {
    die('State mismatch. Possible CSRF attack.');
  }
  $client->authenticate($_GET['code']);
  $_SESSION['access_token'] = $client->getAccessToken();
  $redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . '/';
  header('Location: ' . filter_var($redirect_uri, FILTER_SANITIZE_URL));
}

Python

In diesem Beispiel wird das Flask-Framework verwendet. Es führt unter http://localhost:8080 eine Webanwendung aus, mit der Sie OAuth 2.0 testen können. Ablauf. Wenn Sie diese URL aufrufen, sollten Sie vier Links sehen:

• API-Anfrage testen:Dieser Link verweist auf eine Seite, auf der versucht wird, eine Beispiel-API auszuführen. Falls erforderlich, wird der Autorisierungsvorgang gestartet. Wenn der Vorgang erfolgreich war, wird auf der Seite API-Antwort.
• Authentifizierung direkt testen:Dieser Link verweist auf eine Seite, über die versucht wird, den Nutzer den Autorisierungsvorgang durchlaufen. Die App fordert die Berechtigung an, Autorisierte API-Anfragen im Namen des Nutzers senden
• Aktuelle Anmeldedaten widerrufen: Dieser Link verweist auf eine Seite, die widerruft Berechtigungen, die der Nutzer der Anwendung bereits gewährt hat.
• Löschen Sie die Anmeldedaten für die Flask-Sitzung: Über diesen Link werden die Anmeldedaten für die Autorisierung gelöscht, die in der Flask-Sitzung gespeichert sind. So sehen Sie, was passieren würde, wenn ein Nutzer, erteilte Berechtigung für deine App hat versucht, eine API-Anfrage in einer neuen Sitzung auszuführen. Außerdem können Sie damit sehen Sie die API-Antwort, die Ihre App erhalten würde, wenn ein Nutzer Ihrem Konto Berechtigungen App ausgeführt haben und die App trotzdem versucht hat, eine Anfrage mit einem widerrufenen Zugriffstoken zu autorisieren.

# -*- coding: utf-8 -*-

import os
import flask
import requests

import google.oauth2.credentials
import google_auth_oauthlib.flow
import googleapiclient.discovery

# This variable specifies the name of a file that contains the OAuth 2.0
# information for this application, including its client_id and client_secret.
CLIENT_SECRETS_FILE = "client_secret.json"

# This OAuth 2.0 access scope allows for full read/write access to the
# authenticated user's account and requires requests to use an SSL connection.
SCOPES = ['https://www.googleapis.com/auth/youtube.force-ssl']
API_SERVICE_NAME = 'youtube'
API_VERSION = 'v3'

app = flask.Flask(__name__)
# Note: A secret key is included in the sample so that it works.
# If you use this code in your application, replace this with a truly secret
# key. See https://flask.palletsprojects.com/quickstart/#sessions.
app.secret_key = 'REPLACE ME - this value is here as a placeholder.'


@app.route('/')
def index():
  return print_index_table()


@app.route('/test')
def test_api_request():
  if 'credentials' not in flask.session:
    return flask.redirect('authorize')

  # Load credentials from the session.
  credentials = google.oauth2.credentials.Credentials(
      **flask.session['credentials'])

  youtube = googleapiclient.discovery.build(
      API_SERVICE_NAME, API_VERSION, credentials=credentials)

  broadcasts = youtube.liveBroadcasts().list(part='id,snippet', mine=True).execute()

  # Save credentials back to session in case access token was refreshed.
  # ACTION ITEM: In a production app, you likely want to save these
  #              credentials in a persistent database instead.
  flask.session['credentials'] = credentials_to_dict(credentials)

  return flask.jsonify(**broadcasts)


@app.route('/authorize')
def authorize():
  # Create flow instance to manage the OAuth 2.0 Authorization Grant Flow steps.
  flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
      CLIENT_SECRETS_FILE, scopes=SCOPES)

  # The URI created here must exactly match one of the authorized redirect URIs
  # for the OAuth 2.0 client, which you configured in the API Console. If this
  # value doesn't match an authorized URI, you will get a 'redirect_uri_mismatch'
  # error.
  flow.redirect_uri = flask.url_for('oauth2callback', _external=True)

  authorization_url, state = flow.authorization_url(
      # Enable offline access so that you can refresh an access token without
      # re-prompting the user for permission. Recommended for web server apps.
      access_type='offline',
      # Enable incremental authorization. Recommended as a best practice.
      include_granted_scopes='true')

  # Store the state so the callback can verify the auth server response.
  flask.session['state'] = state

  return flask.redirect(authorization_url)


@app.route('/oauth2callback')
def oauth2callback():
  # Specify the state when creating the flow in the callback so that it can
  # verified in the authorization server response.
  state = flask.session['state']

  flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
      CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
  flow.redirect_uri = flask.url_for('oauth2callback', _external=True)

  # Use the authorization server's response to fetch the OAuth 2.0 tokens.
  authorization_response = flask.request.url
  flow.fetch_token(authorization_response=authorization_response)

  # Store credentials in the session.
  # ACTION ITEM: In a production app, you likely want to save these
  #              credentials in a persistent database instead.
  credentials = flow.credentials
  flask.session['credentials'] = credentials_to_dict(credentials)

  return flask.redirect(flask.url_for('test_api_request'))


@app.route('/revoke')
def revoke():
  if 'credentials' not in flask.session:
    return ('You need to <a href="/authorize">authorize</a> before ' +
            'testing the code to revoke credentials.')

  credentials = google.oauth2.credentials.Credentials(
    **flask.session['credentials'])

  revoke = requests.post('https://oauth2.googleapis.com/revoke',
      params={'token': credentials.token},
      headers = {'content-type': 'application/x-www-form-urlencoded'})

  status_code = getattr(revoke, 'status_code')
  if status_code == 200:
    return('Credentials successfully revoked.' + print_index_table())
  else:
    return('An error occurred.' + print_index_table())


@app.route('/clear')
def clear_credentials():
  if 'credentials' in flask.session:
    del flask.session['credentials']
  return ('Credentials have been cleared.<br><br>' +
          print_index_table())


def credentials_to_dict(credentials):
  return {'token': credentials.token,
          'refresh_token': credentials.refresh_token,
          'token_uri': credentials.token_uri,
          'client_id': credentials.client_id,
          'client_secret': credentials.client_secret,
          'scopes': credentials.scopes}

def print_index_table():
  return ('<table>' +
          '<tr><td><a href="/test">Test an API request</a></td>' +
          '<td>Submit an API request and see a formatted JSON response. ' +
          '    Go through the authorization flow if there are no stored ' +
          '    credentials for the user.</td></tr>' +
          '<tr><td><a href="/authorize">Test the auth flow directly</a></td>' +
          '<td>Go directly to the authorization flow. If there are stored ' +
          '    credentials, you still might not be prompted to reauthorize ' +
          '    the application.</td></tr>' +
          '<tr><td><a href="/revoke">Revoke current credentials</a></td>' +
          '<td>Revoke the access token associated with the current user ' +
          '    session. After revoking credentials, if you go to the test ' +
          '    page, you should see an <code>invalid_grant</code> error.' +
          '</td></tr>' +
          '<tr><td><a href="/clear">Clear Flask session credentials</a></td>' +
          '<td>Clear the access token currently stored in the user session. ' +
          '    After clearing the token, if you <a href="/test">test the ' +
          '    API request</a> again, you should go back to the auth flow.' +
          '</td></tr></table>')


if __name__ == '__main__':
  # When running locally, disable OAuthlib's HTTPs verification.
  # ACTION ITEM for developers:
  #     When running in production *do not* leave this option enabled.
  os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'

  # Specify a hostname and port that are set as a valid redirect URI
  # for your API project in the Google API Console.
  app.run('localhost', 8080, debug=True)

Ruby

In diesem Beispiel wird das Framework Sinatra verwendet.

require 'google/apis/youtube_v3'
require 'sinatra'
require 'googleauth'
require 'googleauth/stores/redis_token_store'

configure do
  enable :sessions

  set :client_id, Google::Auth::ClientId.from_file('/path/to/client_secret.json')
  set :scope, Google::Apis::DriveV3::AUTH_DRIVE_METADATA_READONLY
  set :token_store, Google::Auth::Stores::RedisTokenStore.new(redis: Redis.new)
  set :authorizer, Google::Auth::WebUserAuthorizer.new(settings.client_id, settings.scope, settings.token_store, '/oauth2callback')
end

get '/' do
  user_id = settings.client_id.id
  credentials = settings.authorizer.get_credentials(user_id, request)
  if credentials.nil?
    redirect settings.authorizer.get_authorization_url(login_hint: user_id, request: request)
  end
  youtube = Google::Apis::YoutubeV3::YouTubeService.new
  broadcasts = youtube.list_liveBroadcasts('id,snippet', mine: true)
  
  "<pre>#{JSON.pretty_generate(broadcasts.to_h)}</pre>"
end

get '/oauth2callback' do
  target_url = Google::Auth::WebUserAuthorizer.handle_auth_callback_deferred(request)
  redirect target_url
end

Node.js

So führen Sie das Beispiel aus:

1. Fügen Sie in der API Consoledie URL der lokalen Computer hinzu. Fügen Sie beispielsweise http://localhost.
2. Achten Sie darauf, dass Sie die Wartung „Langzeitsupport“, eine aktive Version von „Langzeitsupport“ oder die aktuelle Version von Node.js wurde installiert.
3. Erstellen Sie ein neues Verzeichnis und wechseln Sie zu diesem Verzeichnis. Beispiel:

   mkdir ~/nodejs-oauth2-example
   cd ~/nodejs-oauth2-example

4. Install the Google API Client Library for Node.js using npm:

   npm install googleapis

5. Erstellen Sie die Dateien main.js mit dem unten stehenden Inhalt.
6. Führen Sie das Beispiel aus:

   node .\main.js

main.js

const http = require('http');
const https = require('https');
const url = require('url');
const { google } = require('googleapis');
const crypto = require('crypto');
const express = require('express');
const session = require('express-session');

/**
 * To use OAuth2 authentication, we need access to a CLIENT_ID, CLIENT_SECRET, AND REDIRECT_URI.
 * To get these credentials for your application, visit
 * https://console.cloud.google.com/apis/credentials.
 */
const oauth2Client = new google.auth.OAuth2(
  YOUR_CLIENT_ID,
  YOUR_CLIENT_SECRET,
  YOUR_REDIRECT_URL
);

// Access scopes for read-only Drive activity.
const scopes = [
  'https://www.googleapis.com/auth/drive.metadata.readonly'
];
/* Global variable that stores user credential in this code example.
 * ACTION ITEM for developers:
 *   Store user's refresh token in your data store if
 *   incorporating this code into your real app.
 *   For more information on handling refresh tokens,
 *   see https://github.com/googleapis/google-api-nodejs-client#handling-refresh-tokens
 */
let userCredential = null;

async function main() {
  const app = express();

  app.use(session({
    secret: 'your_secure_secret_key', // Replace with a strong secret
    resave: false,
    saveUninitialized: false,
  }));

  // Example on redirecting user to Google's OAuth 2.0 server.
  app.get('/', async (req, res) => {
    // Generate a secure random state value.
    const state = crypto.randomBytes(32).toString('hex');
    // Store state in the session
    req.session.state = state;

    // Generate a url that asks permissions for the Drive activity scope
    const authorizationUrl = oauth2Client.generateAuthUrl({
      // 'online' (default) or 'offline' (gets refresh_token)
      access_type: 'offline',
      /** Pass in the scopes array defined above.
        * Alternatively, if only one scope is needed, you can pass a scope URL as a string */
      scope: scopes,
      // Enable incremental authorization. Recommended as a best practice.
      include_granted_scopes: true,
      // Include the state parameter to reduce the risk of CSRF attacks.
      state: state
    });

    res.redirect(authorizationUrl);
  });

  // Receive the callback from Google's OAuth 2.0 server.
  app.get('/oauth2callback', async (req, res) => {
    // Handle the OAuth 2.0 server response
    let q = url.parse(req.url, true).query;

    if (q.error) { // An error response e.g. error=access_denied
      console.log('Error:' + q.error);
    } else if (q.state !== req.session.state) { //check state value
      console.log('State mismatch. Possible CSRF attack');
      res.end('State mismatch. Possible CSRF attack');
    } else { // Get access and refresh tokens (if access_type is offline)
      let { tokens } = await oauth2Client.getToken(q.code);
      oauth2Client.setCredentials(tokens);

      /** Save credential to the global variable in case access token was refreshed.
        * ACTION ITEM: In a production app, you likely want to save the refresh token
        *              in a secure persistent database instead. */
      userCredential = tokens;

      // Example of using Google Drive API to list filenames in user's Drive.
      const drive = google.drive('v3');
      drive.files.list({
        auth: oauth2Client,
        pageSize: 10,
        fields: 'nextPageToken, files(id, name)',
      }, (err1, res1) => {
        if (err1) return console.log('The API returned an error: ' + err1);
        const files = res1.data.files;
        if (files.length) {
          console.log('Files:');
          files.map((file) => {
            console.log(`${file.name} (${file.id})`);
          });
        } else {
          console.log('No files found.');
        }
      });
    }
  });

  // Example on revoking a token
  app.get('/revoke', async (req, res) => {
    // Build the string for the POST request
    let postData = "token=" + userCredential.access_token;

    // Options for POST request to Google's OAuth 2.0 server to revoke a token
    let postOptions = {
      host: 'oauth2.googleapis.com',
      port: '443',
      path: '/revoke',
      method: 'POST',
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded',
        'Content-Length': Buffer.byteLength(postData)
      }
    };

    // Set up the request
    const postReq = https.request(postOptions, function (res) {
      res.setEncoding('utf8');
      res.on('data', d => {
        console.log('Response: ' + d);
      });
    });

    postReq.on('error', error => {
      console.log(error)
    });

    // Post the request with data
    postReq.write(postData);
    postReq.end();
  });


  const server = http.createServer(app);
  server.listen(80);
}
main().catch(console.error);

HTTP/REST

In diesem Python-Beispiel wird das Flask-Framework verwendet. und der Requests-Bibliothek, um das OAuth 2.0-Web-Flow. Wir empfehlen die Verwendung der Google API-Clientbibliothek für Python für diesen Ablauf. Der Parameter auf dem Tab "Python" dagegen die Clientbibliothek verwendet.)

import json

import flask
import requests


app = flask.Flask(__name__)

CLIENT_ID = '123456789.apps.googleusercontent.com'
CLIENT_SECRET = 'abc123'  # Read from a file or environmental variable in a real app
SCOPE = 'https://www.googleapis.com/auth/youtube.force-ssl'
REDIRECT_URI = 'http://example.com/oauth2callback'


@app.route('/')
def index():
  if 'credentials' not in flask.session:
    return flask.redirect(flask.url_for('oauth2callback'))
  credentials = json.loads(flask.session['credentials'])
  if credentials['expires_in'] <= 0:
    return flask.redirect(flask.url_for('oauth2callback'))
  else:
    headers = {'Authorization': 'Bearer {}'.format(credentials['access_token'])}
    req_uri = 'https://youtube.googleapis.com/youtube/v3/liveBroadcasts'
    r = requests.get(req_uri, headers=headers)
    return r.text


@app.route('/oauth2callback')
def oauth2callback():
  if 'code' not in flask.request.args:
    state = str(uuid.uuid4())
    flask.session['state'] = state
    auth_uri = ('https://accounts.google.com/o/oauth2/v2/auth?response_type=code'
                '&client_id={}&redirect_uri={}&scope={}&state={}').format(CLIENT_ID, REDIRECT_URI,
                                                                          SCOPE, state)
    return flask.redirect(auth_uri)
  else:
    if 'state' not in flask.request.args or flask.request.args['state'] != flask.session['state']:
      return 'State mismatch. Possible CSRF attack.', 400

    auth_code = flask.request.args.get('code')
    data = {'code': auth_code,
            'client_id': CLIENT_ID,
            'client_secret': CLIENT_SECRET,
            'redirect_uri': REDIRECT_URI,
            'grant_type': 'authorization_code'}
    r = requests.post('https://oauth2.googleapis.com/token', data=data)
    flask.session['credentials'] = r.text
    return flask.redirect(flask.url_for('index'))


if __name__ == '__main__':
  import uuid
  app.secret_key = str(uuid.uuid4())
  app.debug = False
  app.run()

PHP

$client->setIncludeGrantedScopes(true);

Python

Legen Sie in Python das Schlüsselwortargument include_granted_scopes auf true fest: Prüfen Sie, ob eine Autorisierungsanfrage zuvor gewährte Bereiche enthält. Es ist sehr möglich, dass include_granted_scopes ist nicht das einzige Schlüsselwortargument, das Sie festlegen, da wie im folgenden Beispiel dargestellt.

authorization_url, state = flow.authorization_url(
    # Enable offline access so that you can refresh an access token without
    # re-prompting the user for permission. Recommended for web server apps.
    access_type='offline',
    # Enable incremental authorization. Recommended as a best practice.
    include_granted_scopes='true')

Ruby

auth_client.update!(
  :additional_parameters => {"include_granted_scopes" => "true"}
)

Node.js

const authorizationUrl = oauth2Client.generateAuthUrl({
  // 'online' (default) or 'offline' (gets refresh_token)
  access_type: 'offline',
  /** Pass in the scopes array defined above.
    * Alternatively, if only one scope is needed, you can pass a scope URL as a string */
  scope: scopes,
  // Enable incremental authorization. Recommended as a best practice.
  include_granted_scopes: true
});

HTTP/REST

In diesem Beispiel fordert die aufrufende Anwendung Zugriff zum Abrufen des YouTube-Daten des Nutzers zusätzlich zu jedem anderen Zugriff, den der Nutzer die der Anwendung bereits gewährt wurden.

GET https://accounts.google.com/o/oauth2/v2/auth?
  scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fyoutube.force-ssl&
  access_type=offline&
  state=security_token%3D138rk%3Btarget_url%3Dhttp...index&
  redirect_uri=http%3A%2F%2Flocalhost%2Foauth2callback&
  response_type=code&
  client_id=client_id&
  include_granted_scopes=true

      

PHP

If your application needs offline access to a Google API, set the API client's access type to offline:

$client->setAccessType("offline");

Nachdem ein Nutzer Offlinezugriff auf die angeforderten Bereiche gewährt hat, können Sie die API weiter verwenden -Client, um im Namen des Nutzers auf Google APIs zuzugreifen, wenn dieser offline ist. Clientobjekt wird das Zugriffstoken nach Bedarf aktualisiert.

Python

Legen Sie in Python das Schlüsselwortargument access_type auf offline fest, um sicherzustellen, dass Sie das Zugriffstoken aktualisieren können, ohne den Nutzer erneut zur Eingabe Berechtigung. Es ist gut möglich, dass access_type nicht das einzige Keyword ist -Arguments, das Sie festlegen, wie im folgenden Beispiel gezeigt.

authorization_url, state = flow.authorization_url(
    # Enable offline access so that you can refresh an access token without
    # re-prompting the user for permission. Recommended for web server apps.
    access_type='offline',
    # Enable incremental authorization. Recommended as a best practice.
    include_granted_scopes='true')

Nachdem ein Nutzer Offlinezugriff auf die angeforderten Bereiche gewährt hat, können Sie die API weiter verwenden -Client, um im Namen des Nutzers auf Google APIs zuzugreifen, wenn dieser offline ist. Clientobjekt wird das Zugriffstoken nach Bedarf aktualisiert.

Ruby

Wenn Ihre Anwendung Offlinezugriff auf eine Google API benötigt, legen Sie den Zugriffstyp des API-Clients auf offline:

auth_client.update!(
  :additional_parameters => {"access_type" => "offline"}
)

Nachdem ein Nutzer Offlinezugriff auf die angeforderten Bereiche gewährt hat, können Sie die API weiter verwenden -Client, um im Namen des Nutzers auf Google APIs zuzugreifen, wenn dieser offline ist. Clientobjekt wird das Zugriffstoken nach Bedarf aktualisiert.

Node.js

Wenn Ihre Anwendung Offlinezugriff auf eine Google API benötigt, legen Sie den Zugriffstyp des API-Clients auf offline:

const authorizationUrl = oauth2Client.generateAuthUrl({
  // 'online' (default) or 'offline' (gets refresh_token)
  access_type: 'offline',
  /** Pass in the scopes array defined above.
    * Alternatively, if only one scope is needed, you can pass a scope URL as a string */
  scope: scopes,
  // Enable incremental authorization. Recommended as a best practice.
  include_granted_scopes: true
});

Nachdem ein Nutzer Offlinezugriff auf die angeforderten Bereiche gewährt hat, können Sie die API weiter verwenden -Client, um im Namen des Nutzers auf Google APIs zuzugreifen, wenn dieser offline ist. Clientobjekt wird das Zugriffstoken nach Bedarf aktualisiert.

Zugriffstokens laufen ab. Diese Bibliothek verwendet automatisch ein Aktualisierungstoken, um einen neuen Zugriff zu erhalten wenn es bald abläuft. Eine einfache Möglichkeit, immer die neuesten Tokens zu speichern ist die Verwendung des Token-Ereignisses:

oauth2Client.on('tokens', (tokens) => {
  if (tokens.refresh_token) {
    // store the refresh_token in your secure persistent database
    console.log(tokens.refresh_token);
  }
  console.log(tokens.access_token);
});

Dieses Tokenereignis tritt nur bei der ersten Autorisierung auf. Sie müssen Ihre access_type an offline beim Aufrufen von generateAuthUrl um das Aktualisierungstoken zu empfangen. Wenn Sie Ihrer App die erforderlichen Berechtigungen bereits gewährt haben ohne die entsprechenden Einschränkungen für den Empfang eines Aktualisierungstokens festzulegen, müssen Sie Autorisieren Sie die Anwendung noch einmal, um ein neues Aktualisierungstoken zu erhalten.

Wenn Sie die refresh_token zu einem späteren Zeitpunkt festlegen möchten, können Sie die Methode setCredentials verwenden:

oauth2Client.setCredentials({
  refresh_token: `STORED_REFRESH_TOKEN`
});

Sobald der Client ein Aktualisierungstoken hat, werden die Zugriffstokens automatisch abgerufen und aktualisiert. im nächsten Aufruf an die API ein.

HTTP/REST

Zum Aktualisieren eines Zugriffstokens sendet Ihre Anwendung eine HTTPS-POST-Anfrage an den Autorisierungsserver von Google (https://oauth2.googleapis.com/token) senden, enthält die folgenden Parameter:

Das folgende Snippet zeigt eine Beispielanfrage:

POST /token HTTP/1.1
Host: oauth2.googleapis.com
Content-Type: application/x-www-form-urlencoded

client_id=your_client_id&
client_secret=your_client_secret&
refresh_token=refresh_token&
grant_type=refresh_token

Solange der Nutzer den der Anwendung gewährten Zugriff nicht widerrufen hat, kann der Tokenserver gibt ein JSON-Objekt zurück, das ein neues Zugriffstoken enthält. Das folgende Snippet zeigt ein Beispiel Antwort:

{
  "access_token": "1/fFAGRNJru1FTz70BzhT3Zg",
  "expires_in": 3920,
  "scope": "https://www.googleapis.com/auth/drive.metadata.readonly",
  "token_type": "Bearer"
}

Beachten Sie, dass die Anzahl der Aktualisierungstokens, die ausgestellt werden, begrenzt ist. ein Limit pro Client/Nutzer-Kombination und eine weitere pro Nutzer für alle Clients. Aktualisierungstokens speichern und verwenden sie, solange sie gültig sind. Wenn Ihre Anwendung zu viele Aktualisierungstokens anfordert, können diese Limits erreicht werden. In diesem Fall sind ältere Aktualisierungstokens funktioniert nicht mehr.

PHP

Wenn Sie ein Token programmatisch widerrufen möchten, rufen Sie revokeToken() auf:

$client->revokeToken();

Python

Wenn Sie ein Token programmatisch widerrufen möchten, senden Sie eine Anfrage an https://oauth2.googleapis.com/revoke, der das Token als Parameter enthält und den Parameter festlegt Content-Type-Header:

requests.post('https://oauth2.googleapis.com/revoke',
    params={'token': credentials.token},
    headers = {'content-type': 'application/x-www-form-urlencoded'})

Ruby

Wenn Sie ein Token programmatisch widerrufen möchten, senden Sie eine HTTP-Anfrage an die oauth2.revoke Endpunkt:

uri = URI('https://oauth2.googleapis.com/revoke')
response = Net::HTTP.post_form(uri, 'token' => auth_client.access_token)

Das Token kann ein Zugriffstoken oder ein Aktualisierungstoken sein. Wenn das Token ein Zugriffstoken ist und ein entsprechendes Aktualisierungstoken, wird auch das Aktualisierungstoken widerrufen.

Wenn der Widerruf erfolgreich verarbeitet wurde, lautet der Statuscode der Antwort: 200 Bei Fehlerbedingungen wird der Statuscode 400 zusammen mit einem Fehlercode angezeigt.

Node.js

Wenn Sie ein Token programmatisch widerrufen möchten, senden Sie eine HTTPS-POST-Anfrage an /revoke Endpunkt:

const https = require('https');

// Build the string for the POST request
let postData = "token=" + userCredential.access_token;

// Options for POST request to Google's OAuth 2.0 server to revoke a token
let postOptions = {
  host: 'oauth2.googleapis.com',
  port: '443',
  path: '/revoke',
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Content-Length': Buffer.byteLength(postData)
  }
};

// Set up the request
const postReq = https.request(postOptions, function (res) {
  res.setEncoding('utf8');
  res.on('data', d => {
    console.log('Response: ' + d);
  });
});

postReq.on('error', error => {
  console.log(error)
});

// Post the request with data
postReq.write(postData);
postReq.end();

Der Tokenparameter kann ein Zugriffstoken oder ein Aktualisierungstoken sein. Wenn das Token ein Zugriffstoken ist und ein entsprechendes Aktualisierungstoken, wird auch das Aktualisierungstoken widerrufen.

Wenn der Widerruf erfolgreich verarbeitet wurde, lautet der Statuscode der Antwort: 200 Bei Fehlerbedingungen wird der Statuscode 400 zusammen mit einem Fehlercode angezeigt.

HTTP/REST

Zum programmatischen Widerrufen eines Tokens sendet Ihre Anwendung eine Anfrage an https://oauth2.googleapis.com/revoke und enthält das Token als Parameter:

curl -d -X -POST --header "Content-type:application/x-www-form-urlencoded" \
        https://oauth2.googleapis.com/revoke?token={token}

Das Token kann ein Zugriffstoken oder ein Aktualisierungstoken sein. Handelt es sich bei dem Token um ein Zugriffstoken mit einem entsprechendes Aktualisierungstoken, wird auch das Aktualisierungstoken widerrufen.

Wenn der Widerruf erfolgreich verarbeitet wurde, lautet der HTTP-Statuscode der Antwort: 200 Bei Fehlerbedingungen wird der HTTP-Statuscode 400 zusammen mit mit einem Fehlercode.