將 OAuth 2.0 用於網路伺服器應用程式

PHP

如要執行本文件中的 PHP 程式碼範例，您需要：

• PHP 5.6 以上版本，並且已安裝指令列介面 (CLI) 和 JSON 擴充功能。
• Composer 依附元件管理工具。

• PHP 適用的 Google API 用戶端程式庫：

  composer require google/apiclient:^2.10

Python

如要執行本文件中的 Python 程式碼範例，您需要：

• Python 2.6 以上版本
• pip 套件管理工具。
• Python 適用的 Google API 用戶端程式庫：

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

• 使用者授權的 google-auth、google-auth-oauthlib 和 google-auth-httplib2。

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

• Flask Python 網頁應用程式架構。

  pip install --upgrade flask

• requests HTTP 程式庫。

  pip install --upgrade requests

小茹

如要執行本文件中的 Ruby 程式碼範例，您需要：

• Ruby 2.6 以上版本

• Ruby 適用的 Google 驗證程式庫：

  gem install googleauth

• Sinatra Ruby 網頁應用程式架構。

  gem install sinatra

Node.js

如要執行本文件中的 Node.js 程式碼範例，您需要：

• Node.js 的維護 LTS、運作中的 LTS 或現行版本。

• Google API Node.js 用戶端：

  npm install googleapis crypto express express-session

HTTP/REST

您無需安裝任何程式庫，即可直接呼叫 OAuth 2.0 端點。

PHP

下列程式碼片段會建立 Google\Client() 物件，用於定義授權要求中的參數。

這個物件會使用 client_secret.json 檔案中的資訊來識別您的應用程式。如要進一步瞭解這個檔案，請參閱建立授權憑證。這個物件也會指出應用程式要求存取的範圍，以及應用程式驗證端點的網址 (用來處理 Google OAuth 2.0 伺服器的回應)。最後，程式碼會設定選用的 access_type 和 include_granted_scopes 參數。

舉例來說，如要要求離線存取使用者 YouTube 資料，請按照下列步驟操作：

$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

下列程式碼片段使用 google-auth-oauthlib.flow 模組建構授權要求。

這個程式碼會建構 Flow 物件，這個值會使用您在建立授權憑證後下載的 client_secret.json 檔案中的資訊。該物件也會指出應用程式要求存取的範圍，以及應用程式驗證端點的網址 (用來處理 Google OAuth 2.0 伺服器的回應)。最後，程式碼會設定選用的 access_type 和 include_granted_scopes 參數。

舉例來說，如要要求離線存取使用者 YouTube 資料，請按照下列步驟操作：

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

小茹

使用您建立的 client_secrets.json 檔案，設定應用程式中的用戶端物件。設定用戶端物件時，您會指定應用程式需要存取的範圍，以及應用程式的驗證端點網址，以便處理 OAuth 2.0 伺服器的回應。

舉例來說，如要要求離線存取使用者 YouTube 資料，請按照下列步驟操作：

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

您的應用程式使用用戶端物件執行 OAuth 2.0 作業，例如產生授權要求網址，以及將存取權杖套用至 HTTP 要求。

Node.js

下列程式碼片段會建立 google.auth.OAuth2 物件，定義授權要求中的參數。

這個物件會使用 client_secret.json 檔案中的資訊來識別您的應用程式。如要向使用者要求權限以擷取存取權杖，請將使用者重新導向至同意聲明頁面。建立同意頁面網址的方法如下：

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
});

重要注意事項 - 系統只會在第一項授權上傳回 refresh_token。詳情請參閱 這篇文章。

HTTP/REST

Google 的 OAuth 2.0 端點位於 https://accounts.google.com/o/oauth2/v2/auth。這個端點只能透過 HTTPS 存取。系統會拒絕純 HTTP 連線。

PHP

1. 產生網址以向 Google 的 OAuth 2.0 伺服器要求存取權：

   $auth_url = $client->createAuthUrl();

2. 將使用者重新導向至 $auth_url：

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

Python

以下範例說明如何使用 Flask 網頁應用程式架構，將使用者重新導向至授權網址：

return flask.redirect(authorization_url)

小茹

1. 產生網址以向 Google 的 OAuth 2.0 伺服器要求存取權：

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

2. 將使用者重新導向至 auth_uri。

Node.js

1. 使用步驟 1 generateAuthUrl 方法中產生的網址 authorizationUrl，向 Google 的 OAuth 2.0 伺服器要求存取權。
2. 將使用者重新導向至 authorizationUrl。

   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

建立要求網址之後，請將使用者重新導向至該網址。

PHP

如要用授權碼交換存取權杖，請使用 authenticate 方法：

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

您可以使用 getAccessToken 方法擷取存取權杖：

$access_token = $client->getAccessToken();

Python

在回呼頁面上，使用 google-auth 程式庫驗證授權伺服器回應。然後使用 flow.fetch_token 方法，在該回應中交換授權碼以取得存取權杖：

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}

小茹

在回呼頁面上，使用 googleauth 程式庫驗證授權伺服器回應。使用 authorizer.handle_auth_callback_deferred 方法儲存授權碼，並重新導向回原先要求授權的網址。這樣就能暫時在使用者的工作階段中儲存結果，藉此延後程式碼交換作業。

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

Node.js

如要用授權碼交換存取權杖，請使用 getToken 方法：

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

如要用授權碼交換存取權杖，請呼叫 https://oauth2.googleapis.com/token 端點並設定下列參數：

下列程式碼片段為要求範例：

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 傳回 JSON 物件，其中包含短期存取權杖和更新權杖，藉此回應這項要求。 請注意，只有在應用程式對 Google 授權伺服器發出的初始要求中，將 access_type 參數設為 offline 時，系統才會傳回更新權杖。

回應中會包含以下欄位：

以下程式碼片段為回應範例：

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

完成下列步驟，即可使用存取權杖呼叫 Google API：

1. 如要將存取權杖套用至新的 Google\Client 物件 (例如，假設您將存取權杖儲存在使用者工作階段中)，請使用 setAccessToken 方法：

   $client->setAccessToken($access_token);

2. 為您要呼叫的 API 建立服務物件。如要建立服務物件，您可以向要呼叫的 API 的建構函式提供已授權的 Google\Client 物件。舉例來說，如要呼叫 YouTube Data API，請執行以下操作：

   $youtube = new Google_Service_YouTube($client);

3. 使用服務物件提供的介面向 API 服務發出要求。舉例來說，如要使用 YouTube Data API 擷取已驗證使用者頻道的現場直播清單：

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

Python

取得存取權杖後，應用程式即可使用該權杖來代表指定使用者帳戶或服務帳戶，授權 API 要求。使用使用者專屬授權憑證為您要呼叫的 API 建立服務物件，然後使用該物件發出已授權的 API 要求。

1. 為您要呼叫的 API 建立服務物件。如要建立服務物件，您可以使用該 API 的名稱、版本和使用者憑證呼叫 googleapiclient.discovery 程式庫的 build 方法： 舉例來說，呼叫第 3 版的 YouTube Data API：

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

2. 使用服務物件提供的介面向 API 服務發出要求。舉例來說，如要使用 YouTube Data API 擷取已驗證使用者頻道的現場直播清單：

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

小茹

取得存取權杖後，應用程式即可使用該權杖代表指定使用者帳戶或服務帳戶，提出 API 要求。使用使用者專屬授權憑證為您要呼叫的 API 建立服務物件，然後使用該物件發出已授權的 API 要求。

1. 為您要呼叫的 API 建立服務物件。 舉例來說，如要呼叫第 3 版的 YouTube Data API：

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

2. 設定服務的憑證：

   youtube.authorization = credentials

3. 使用服務物件提供的介面向 API 服務發出要求。舉例來說，如要使用 YouTube Data API 擷取已驗證使用者頻道的現場直播清單，請按照下列步驟操作：

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

或者，您也可以為方法提供 options 參數，藉此依方法提供授權：

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

Node.js

取得存取權杖並將其設為 OAuth2 物件後，請使用該物件呼叫 Google API。應用程式可以使用該權杖，代表指定使用者帳戶或服務帳戶授權 API 要求。為您要呼叫的 API 建立服務物件。

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

應用程式取得存取權杖後，在獲得 API 所需的存取權範圍後，您即可使用權杖，代表指定使用者帳戶呼叫 Google API。如要這麼做，請在對 API 的要求中加入存取權杖，方法是加入 access_token 查詢參數或 Authorization HTTP 標頭 Bearer 值。如果可以的話，建議使用 HTTP 標頭，因為查詢字串通常會顯示在伺服器記錄檔中。在多數情況下，您可以透過用戶端程式庫設定對 Google API 的呼叫 (例如呼叫 YouTube Live Streaming API 時)。

請注意，YouTube Live Streaming API 不支援服務帳戶流程。由於無法將服務帳戶連結至 YouTube 帳戶，因此嘗試透過此流程授權要求時，會產生 NoLinkedYouTubeAccount 錯誤。

如要試用所有 Google API 及查看其範圍，請前往 OAuth 2.0 Playground。

HTTP GET 範例

使用 Authorization: Bearer HTTP 標頭呼叫 liveBroadcasts.list 端點 (YouTube Live Streaming API) 的呼叫可能如下所示。請注意，您必須指定自己的存取權杖：

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

以下示範如何使用 access_token 查詢字串參數，為通過驗證的使用者呼叫相同的 API：

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

curl 個樣本

您可以使用 curl 指令列應用程式測試這些指令。以下為使用 HTTP 標頭選項的範例 (建議)：

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

或者，您也可以使用查詢字串參數選項：

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

PHP

如要執行這個範例：

1. 在 API Console中，將本機電腦的網址新增至重新導向網址清單，例如新增 http://localhost:8080。
2. 建立新目錄並進行變更。例如：

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

3. 使用 Composer 安裝 PHP 適用的 Google API 用戶端程式庫：

   composer require google/apiclient:^2.10

4. 使用以下內容建立 index.php 和 oauth2callback.php 檔案。
5. 使用設定為提供 PHP 的網路伺服器執行範例。如果您使用 PHP 5.6 以上版本，可以使用 PHP 的內建測試網路伺服器：

   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

這個範例使用 Flask 架構。它會在 http://localhost:8080 執行網頁應用程式，讓您測試 OAuth 2.0 流程。您前往該網址時，會看到四個連結：

• 測試 API 要求：這個連結指向嘗試執行範例 API 要求的網頁。如有需要，系統會啟動授權流程。如果成功，頁面就會顯示 API 回應。
• 直接測試驗證流程：這個連結會指向嘗試透過授權流程將使用者導向的網頁。應用程式會要求權限，以代表使用者提交已授權的 API 要求。
• 撤銷目前的憑證：這個連結會指向 撤銷使用者已授予應用程式權限的網頁。
• 清除 Flask 工作階段憑證：這個連結會清除儲存在 Flask 工作階段的授權憑證。這樣一來，您就能瞭解如果使用者已授予應用程式權限，嘗試在新工作階段中執行 API 要求，會發生什麼情況。此外，您也可以透過這個 API，查看使用者撤銷授予應用程式的權限，且應用程式仍在嘗試以已撤銷的存取權權杖授權要求時，應用程式會收到哪些 API 回應。

# -*- 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)

小茹

本範例使用 Sinatra 架構。

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

如要執行這個範例：

1. 在 API Console中，將本機電腦的網址加入重新導向網址清單。例如，新增 http://localhost。
2. 請確認您已安裝 LTS、運作中的 LTS，或是目前安裝的 Node.js 版本。
3. 建立新目錄並進行變更。例如：

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

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

   npm install googleapis

5. 建立含有以下內容的檔案 main.js。
6. 執行範例：

   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

這個 Python 範例使用 Flask 架構和 Requests 程式庫，來示範 OAuth 2.0 網路流程。針對這個流程，我們建議使用 Python 適用的 Google API 用戶端程式庫。(Python 分頁的範例會使用用戶端程式庫)。

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

在 Python 中，將 include_granted_scopes 關鍵字引數設為 true，以確保授權要求包含先前授予的範圍。例如，include_granted_scopes 可能並非您設定的「唯一」關鍵字引數，如以下範例所示。

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

小茹

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

在本範例中，除了使用者已授予應用程式的任何其他存取權，發出呼叫的應用程式也會要求擷取使用者的 YouTube 資料，以擷取使用者的 YouTube 資料。

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

使用者授予要求範圍的離線存取功能後，您可以在使用者離線時，繼續透過 API 用戶端代表使用者存取 Google API。用戶端物件會視需要更新存取權杖。

Python

在 Python 中，將 access_type 關鍵字引數設為 offline，以確保您不必重新提示使用者授予權限，就能重新整理存取權杖。例如，access_type 可能並非您設定的「唯一」關鍵字引數，如以下範例所示。

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

使用者授予要求範圍的離線存取功能後，您可以在使用者離線時，繼續透過 API 用戶端代表使用者存取 Google API。用戶端物件會視需要更新存取權杖。

小茹

如果您的應用程式需要離線存取 Google API，請將 API 用戶端的存取權類型設為 offline：

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

使用者授予要求範圍的離線存取功能後，您可以在使用者離線時，繼續透過 API 用戶端代表使用者存取 Google API。用戶端物件會視需要更新存取權杖。

Node.js

如果您的應用程式需要離線存取 Google API，請將 API 用戶端的存取權類型設為 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
});

使用者授予要求範圍的離線存取功能後，您可以在使用者離線時，繼續透過 API 用戶端代表使用者存取 Google API。用戶端物件會視需要更新存取權杖。

存取權杖會過期。這個程式庫會自動使用更新權杖，在存取權杖即將到期時取得新的存取權杖。如果想要一律儲存最新權杖，最簡單的方法就是使用權杖事件：

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);
});

這個權杖事件只會發生在第一次授權中，而且在呼叫 generateAuthUrl 方法接收更新權杖時，您必須將 access_type 設為 offline。如果您已經為應用程式提供必要權限，但未設定接收更新權杖的適當限制，那麼您必須重新授權應用程式，才能接收新的更新權杖。

如要稍後再設定 refresh_token，您可以使用 setCredentials 方法：

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

用戶端取得更新權杖後，系統就會在下次呼叫 API 時取得並自動更新存取權杖。

HTTP/REST

為了重新整理存取權杖，應用程式會將 HTTPS POST 要求傳送至 Google 的授權伺服器 (https://oauth2.googleapis.com/token)，其中包含下列參數：

下列程式碼片段為要求範例：

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

只要使用者尚未撤銷授予應用程式的存取權，憑證伺服器就會傳回內含新存取權杖的 JSON 物件。以下程式碼片段為回應範例：

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

請注意，系統即將核發的更新權杖數量有限制；每個用戶端/使用者組合各有一項限制，所有用戶端對每位使用者另有限制。建議您將更新權杖儲存在長期儲存空間，只要該權杖維持有效狀態，就能繼續使用。如果您的應用程式要求過多的更新權杖，可能會達到這些限制，而較舊的更新權杖就會停止運作。

PHP

如要透過程式輔助的方式撤銷權杖，請呼叫 revokeToken()：

$client->revokeToken();

Python

如要透過程式輔助方式撤銷權杖，請向 https://oauth2.googleapis.com/revoke 發出包含權杖做為參數的要求，並設定 Content-Type 標頭：

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

小茹

如要透過程式撤銷權杖，請向 oauth2.revoke 端點發出 HTTP 要求：

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

可以是存取權杖或更新權杖。如果權杖是存取權杖，且有對應的更新權杖，系統也會撤銷更新權杖。

如果撤銷成功處理，回應的狀態碼為 200。如果是錯誤狀況，系統會傳回狀態碼 400 和錯誤代碼。

Node.js

如要透過程式輔助方式撤銷權杖，請向 /revoke 端點發出 HTTPS POST 要求：

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();

權杖參數可以是存取權杖或更新權杖。如果權杖是存取權杖，且有對應的更新權杖，系統也會撤銷更新權杖。

如果撤銷成功處理，回應的狀態碼為 200。如果是錯誤狀況，系統會傳回狀態碼 400 和錯誤代碼。

HTTP/REST

如要透過程式輔助方式撤銷權杖，應用程式會向 https://oauth2.googleapis.com/revoke 發出要求，並在參數中加入權杖：

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

可以是存取權杖或更新權杖。如果權杖是存取權杖，且有對應的更新權杖，系統也會撤銷更新權杖。

如果撤銷成功處理，回應的 HTTP 狀態碼會是 200。如果是錯誤狀況，會傳回 HTTP 狀態碼 400 和錯誤代碼。