Ta strona została przetłumaczona przez Cloud Translation API.

OAuth w bibliotekach klienta protokołu danych Google

Ostrzeżenie: ta strona dotyczy starszych interfejsów API Google – interfejsów API danych Google – dotyczy tylko interfejsów API wymienionych w katalogu interfejsów API danych Google, z których wiele zostało zastąpionych nowszych. Informacje na temat konkretnego nowego interfejsu API można znaleźć w dokumentacji nowego interfejsu API. Informacje o autoryzowaniu żądań za pomocą nowszego interfejsu API znajdziesz w artykule Uwierzytelnianie i autoryzacja kont Google.

Ten dokument opisuje, jak korzystać z bibliotek klienta interfejsu Google Data API do łączenia się z Google OAuth.

Interfejs OAuth umożliwia aplikacji internetowej dostęp do usługi Google w imieniu użytkownika. Aby zapewnić wysoki poziom bezpieczeństwa, OAuth umożliwia aplikacji uzyskiwanie tokena dostępu bez obsługi danych logowania użytkownika.

Biblioteki klienta interfejsu Google Data API udostępniają metody ułatwiające korzystanie z protokołu OAuth w aplikacji internetowej. Konkretnie chodzi tu o sposób budowania pozyskiwania tokena żądania, autoryzowania tokena żądania i wymiany autoryzowanego tokena żądania na token dostępu. Biblioteki obsługują również niezbędne algorytmy podpisywania, gdy wysyłają żądania do usługi danych Google.

Odbiorcy

Ten dokument jest przeznaczony dla programistów, którzy chcą, aby ich aplikacje internetowe miały dostęp do usług Google w imieniu użytkowników za pomocą bibliotek klienta interfejsów API danych Google.

W tym dokumencie założono, że znasz interfejs OAuth i ogólny proces wdrażania protokołu OAuth do aplikacji internetowej. Pełny opis protokołu OAuth znajdziesz w artykule Uwierzytelnianie OAuth do aplikacji internetowych lub w oficjalnej specyfikacji na stronie oauth.net.

korzystanie z trzyetapowej autoryzacji OAuth oraz interfejsów API danych Google bez bibliotek klienta.

Jeśli chcesz, aby Twoja aplikacja internetowa miała dostęp do usługi danych Google przy użyciu protokołu OAuth jako metody autoryzacji, musisz zapoznać się z artykułem Uwierzytelnianie OAuth do aplikacji internetowych. Nie musisz korzystać z bibliotek klienta interfejsów API danych Google, jeśli nie chcesz.

Oto zestawienie metod uwierzytelniania użytkownika przy użyciu protokołu OAuth w aplikacji:

Twoja aplikacja wysyła podpisane żądanie pobrania początkowego tokena żądania OAuth z punktu końcowego OAuthRequestToken.
Aplikacja przekierowuje użytkownika do odpowiedniego adresu URL OAuthAuthorizeToken w celu autoryzacji tokena żądania.
Po przyznaniu dostępu użytkownik jest przekierowany z powrotem do aplikacji (adres URL oauth_callback)
Twoja aplikacja wysyła podpisane żądanie przeniesienia autoryzowanego tokena żądania do tokena dostępu za pomocą punktu końcowego OAuthGetAccessToken.

Biblioteki klienta interfejsów API danych Google upraszczają ten proces przez obsługę różnych szczegółów. W tym dokumencie opisujemy, jak to zrobić.

Rejestrowanie aplikacji internetowej

OAuth wymaga, aby wszystkie wywołania interfejsu API były podpisane cyfrowo. Google obsługuje metody podpisu HMAC-SHA1 i RSA-SHA1. Aby podpisać prośby, musisz najpierw zarejestrować się w Google. Po zakończeniu rejestracji Google dostarczy Ci klucz klienta (i tajny klucz do użytku w domenie HMAC-SHA1) oraz miejsce, w którym możesz przesłać certyfikat publiczny.

1. Rejestracja domeny

Wykonaj czynności opisane w artykule Rejestracja w aplikacjach internetowych.

2. Tworzenie pary klucza prywatnego i certyfikatu publicznego (opcjonalnie)

Jeśli wybierzesz RSA-SHA1 jako oauth_signature_method, musisz utworzyć samodzielnie podpisany klucz prywatny RSA i publiczny certyfikat. Przykład znajdziesz w sekcji Generowanie samodzielnie prywatnego klucza i certyfikatu publicznego (poniżej).

Korzystanie z 3-etapowej autoryzacji OAuth i interfejsów API danych Google: przykłady z biblioteki klienta

Poniżej dowiesz się, jak korzystać z metod biblioteki klienta interfejsu Google Data API w sposób opisany w sekcji „Praca z OAuth” w dokumentacji OAuth. Wszystkie przykłady w tym dokumencie zakładają, że domena hosta aplikacji to example.com.

Określanie zakresu dostępu do danych

Każda usługa Google określa wartość scope, która określa token dostępu do danych użytkownika. Listę dostępnych wartości znajdziesz w artykule Najczęstsze pytania o dane Google. Aby na przykład użyć interfejsu Documents List API, ustaw scope na https://docs.google.com/feeds/, jak opisano w najczęstszych pytaniach.

Uwaga: ustaw wartość scope na najwęższy adres URL, który umożliwia dostęp. Zmniejsza to ryzyko przypadkowego uzyskania i wycieku danych osobowych. Jeśli na przykład chcesz uzyskać dostęp do prywatnego kanału listy dokumentów bieżącego użytkownika, użyj zakresu https://docs.google.com/feeds/default/private/full zamiast szerszego zakresu, takiego jak https://docs.google.com/feeds/, który zapewnia dostęp do wszystkich kanałów list dokumentów.

Tokeny wielozakresowe

Aby utworzyć tokeny mające dostęp do wielu interfejsów Google Data API, oddziel każdy zakres spacją. Przykład poniżej tworzy token zapewniający dostęp do danych w Dokumentach Google i Kalendarzu Google użytkownika.

scope=https://www.google.com/calendar/feeds/ https://docs.google.com/feeds/

Kodowanie adresów URL

Znaki inne niż ASCII występujące w adresach URL, w tym dwukropek, ukośnik i spacja, muszą być zakodowane w adresie URL, aby mogły być przesyłane przez HTTP. Biblioteki klienta interfejsu API danych Google automatycznie zapisują parametry za Ciebie w adresie URL, więc możesz po prostu przypisywać ciągi parametrów do parametrów niekodowanych w adresie URL. W kodzie możesz na przykład utworzyć takie przypisanie:

scope=https://www.google.com/calendar/feeds/ https://docs.google.com/feeds/

Gdy wywołasz bibliotekę klienta, parametr scope zostanie automatycznie zakodowany do tej wartości:

https%3a%2f%2fwww.google.com%2fcalendar%2ffeeds%2f+https%3a%2f%2fdocs.google.com%2ffeeds%2f

Pobieram token żądania

Java

W przypadku usługi HMAC-SHA1 potrzebujesz sposobu na zachowanie obiektu tajnego tokena uzyskanego w odpowiedzi, aby utworzyć obiekt tokena OAuth powracający ze strony zatwierdzania. Aby to zrobić, ustaw zmienną sesji lub plik cookie.

import com.google.gdata.client.docs.*;
import com.google.gdata.client.authn.oauth.*;

String CONSUMER_KEY = "example.com";
String CONSUMER_SECRET = "abc123doremi";

GoogleOAuthParameters oauthParameters = new GoogleOAuthParameters();
oauthParameters.setOAuthConsumerKey(CONSUMER_KEY);
oauthParameters.setOAuthConsumerSecret(CONSUMER_SECRET);
oauthParameters.setScope("https://docs.google.com/feeds/");
oauthParameters.setOAuthCallback("http://www.example.com/UpgradeToken.jsp");

GoogleOAuthHelper oauthHelper = new GoogleOAuthHelper(new OAuthHmacSha1Signer());
oauthHelper.getUnauthorizedRequestToken(oauthParameters);

Przy użyciu RSA-SHA1 oauth_token_secret nie jest używany, więc nie ma potrzeby utrzymywania obiektu tajnego tokena.

import com.google.gdata.client.docs.*;
import com.google.gdata.client.authn.oauth.*;

String CONSUMER_KEY = "example.com";

GoogleOAuthParameters oauthParameters = new GoogleOAuthParameters();
oauthParameters.setOAuthConsumerKey(CONSUMER_KEY);
oauthParameters.setScope("https://docs.google.com/feeds/");
oauthParameters.setOAuthCallback("http://www.example.com/UpgradeToken.jsp");

PrivateKey privKey = getPrivateKey("/path/to/your/rsakey.pk8");

GoogleOAuthHelper oauthHelper = new GoogleOAuthHelper(new OAuthRsaSha1Signer(privKey));
oauthHelper.getUnauthorizedRequestToken(oauthParameters);

...

public static PrivateKey getPrivateKey(String privKeyFileName) {
  File privKeyFile = new File(privKeyFileName);
  FileInputStream fis = new FileInputStream(privKeyFile);
  DataInputStream dis  = new DataInputStream(fis);

  byte[] privKeyBytes = new byte[(int) privKeyFile.length()];
  dis.read(privKeyBytes);
  dis.close();
  fis.close();

  String BEGIN = "-----BEGIN PRIVATE KEY-----";
  String END = "-----END PRIVATE KEY-----";
  String str = new String(privKeyBytes);
  if (str.contains(BEGIN) && str.contains(END)) {
    str = str.substring(BEGIN.length(), str.lastIndexOf(END));
  }

  KeyFactory fac = KeyFactory.getInstance("RSA");
  EncodedKeySpec privKeySpec = new PKCS8EncodedKeySpec(Base64.decode(str));
  return fac.generatePrivate(privKeySpec);
}

PHP

Użycie HMAC-SHA1 jako metody podpisu:

require_once 'Zend/Oauth/Consumer.php';

session_start();

$CONSUMER_KEY = 'example.com';
$CONSUMER_SECRET = 'abc123doremi';

// Multi-scoped token.
$SCOPES = array(
  'https://docs.google.com/feeds/',
  'https://spreadsheets.google.com/feeds/'
);

$oauthOptions = array(
  'requestScheme' => Zend_Oauth::REQUEST_SCHEME_HEADER,
  'version' => '1.0',
  'consumerKey' => $CONSUMER_KEY,
  'consumerSecret' => $CONSUMER_SECRET,
  'signatureMethod' => 'HMAC-SHA1',
  'callbackUrl' => 'http://myapp.example.com/access_token.php',
  'requestTokenUrl' => 'https://www.google.com/accounts/OAuthGetRequestToken',
  'userAuthorizationUrl' => 'https://www.google.com/accounts/OAuthAuthorizeToken',
  'accessTokenUrl' => 'https://www.google.com/accounts/OAuthGetAccessToken'
);

$consumer = new Zend_Oauth_Consumer($oauthOptions);

// When using HMAC-SHA1, you need to persist the request token in some way.
// This is because you'll need the request token's token secret when upgrading
// to an access token later on. The example below saves the token object as a session variable.
if (!isset($_SESSION['ACCESS_TOKEN'])) {
  $_SESSION['REQUEST_TOKEN'] = serialize($consumer->getRequestToken(array('scope' => implode(' ', $SCOPES))));
}

Użycie RSA-SHA1 jako metody podpisu:

require_once 'Zend/Crypt/Rsa/Key/Private.php';
require_once 'Zend/Oauth/Consumer.php';

session_start();

$CONSUMER_KEY = 'example.com';
$SCOPE = 'https://docs.google.com/feeds/';

$oauthOptions = array(
  'requestScheme' => Zend_Oauth::REQUEST_SCHEME_HEADER,
  'version' => '1.0',
  'consumerKey' => $CONSUMER_KEY,
  'consumerSecret' => new Zend_Crypt_Rsa_Key_Private(file_get_contents(realpath('/path/to/yourRSAPrivateKey.pem'))),
  'signatureMethod' => 'RSA-SHA1',
  'callbackUrl' => 'http://myapp.example.com/access_token.php',
  'requestTokenUrl' => 'https://www.google.com/accounts/OAuthGetRequestToken',
  'userAuthorizationUrl' => 'https://www.google.com/accounts/OAuthAuthorizeToken',
  'accessTokenUrl' => 'https://www.google.com/accounts/OAuthGetAccessToken'
);

$consumer = new Zend_Oauth_Consumer($oauthOptions);

if (!isset($_SESSION['ACCESS_TOKEN'])) {
  $_SESSION['REQUEST_TOKEN'] = serialize($consumer->getRequestToken(array('scope' => $SCOPE)));
}

Python

Użycie HMAC-SHA1 jako metody podpisu:

Jeśli używasz nowszych klas w wersji 2.0 lub nowszej opartych na GDClient, użyj:

import gdata.gauth
import gdata.docs.client

CONSUMER_KEY = 'example.com'
CONSUMER_SECRET = 'abc123doremi'
SCOPES = ['https://docs.google.com/feeds/', 'https://www.google.com/calendar/feeds/']  # example of a multi-scoped token

client = gdata.docs.client.DocsClient(source='yourCompany-YourAppName-v1')

oauth_callback_url = 'http://%s/get_access_token' % self.request.host
request_token = client.GetOAuthToken(
    SCOPES, oauth_callback_url, CONSUMER_KEY, consumer_secret=CONSUMER_SECRET)

# When using HMAC-SHA1, you need to persist the request_token in some way.
# You'll need the token secret when upgrading to an access token later on.
# In Google App Engine, you can use the AeSave helper:
# gdata.gauth.AeSave(request_token, 'myKey')

Użycie RSA-SHA1 jako metody podpisu:

...

f = open('/path/to/yourRSAPrivateKey.pem')
RSA_KEY = f.read()
f.close()

request_token = client.GetOAuthToken(SCOPES, oauth_callback_url, CONSUMER_KEY, rsa_private_key=RSA_KEY)

Jeśli używasz starszych klas 1.0 opartych na GDataService, wywołania mogą się nieznacznie różnić:

import gdata.auth
import gdata.docs.service

CONSUMER_KEY = 'example.com'
CONSUMER_SECRET = 'abc123doremi'

client = gdata.docs.service.DocsService(source='yourCompany-YourAppName-v1')
client.SetOAuthInputParameters(gdata.auth.OAuthSignatureMethod.HMAC_SHA1, CONSUMER_KEY, consumer_secret=CONSUMER_SECRET)

req_token = client.FetchOAuthRequestToken()
client.SetOAuthToken(req_token)

Użycie RSA-SHA1 jako metody podpisu:

...

f = open('/path/to/yourRSAPrivateKey.pem')
RSA_KEY = f.read()
f.close()

client = gdata.docs.service.DocsService(source='yourCompany-YourAppName-v1')
client.SetOAuthInputParameters(gdata.auth.OAuthSignatureMethod.RSA_SHA1, CONSUMER_KEY, rsa_key=RSA_KEY)

SCOPES = ['https://docs.google.com/feeds/', 'https://www.google.com/calendar/feeds/']  # example of a multi-scoped token
req_token = client.FetchOAuthRequestToken(scopes=SCOPES)
client.SetOAuthToken(req_token)

.NET

Użycie HMAC-SHA1 jako metody podpisu:

using Google.GData.Client;

string CONSUMER_KEY = "example.com";
string CONSUMER_SECRET = "abc123doremi";

// Multi-scoped token.
string SCOPE = "https://www.google.com/calendar/feeds/ https://www.google.com/m8/feeds/";

OAuthParameters parameters = new OAuthParameters() {
  ConsumerKey = CONSUMER_KEY,
  ConsumerSecret = CONSUMER_SECRET,
  Scope = SCOPE,
  Callback = "http://myapp.example.com/access_token",
  SignatureMethod = "HMAC-SHA1"
}

OAuthUtil.GetUnauthorizedRequestToken(parameters);

Użycie RSA-SHA1 jako metody podpisu:

RSA-SHA1 is not supported yet.

Autoryzowanie tokena żądania

Aby autoryzować token żądania, aplikacja musi przekierować użytkownika do adresu URL OAuthAuthorizeToken, który zachęca do zalogowania się na konto Google. Więcej informacji o adresie URL OAuthAuthorizeToken znajdziesz w artykule o uwierzytelnianiu OAuth w aplikacjach internetowych.

Aby utworzyć adres URL OAuthAuthorizeToken w swojej aplikacji, użyj tej biblioteki dla każdego klienta. Pamiętaj, że te przykłady stanowią uzupełnienie poprzednich przykładów.

Po utworzeniu adresu URL strony zatwierdzania aplikacja może używać go na różne sposoby do wysyłania użytkownika do modułu obsługi OAuthAuthorizeToken. Najczęstszym sposobem jest przekierowanie użytkownika lub wyświetlenie linku do tej strony.

Wyodrębnianie tokena z adresu URL wywołania zwrotnego

Gdy Google przekierowuje użytkownika do Twojej aplikacji, parametr oauth_token jest dołączany do adresu URL „oauth_callback_url” jako parametru zapytania. Aplikacja powinna następnie wyodrębnić wartość tokena z parametru zapytania adresu URL i ponownie utworzyć parametry OAuth.

Biblioteki klienta udostępniają wygodne metody wyodrębniania oauth_token. Te przykłady są uzupełnieniem poprzednich.

Uaktualnianie do tokena dostępu

Ostatnim krokiem w tokenie protokołu OAuth jest przekształcenie autoryzowanego tokena żądania w token o długotrwałym dostępie za pomocą adresu URL OAuthGetAccessToken, zgodnie z pełną dokumentacją Uwierzytelnianie OAuth dla aplikacji internetowych.

Oto kilka przykładów użycia poszczególnych bibliotek klienta:

Uwaga: jeśli korzystasz z HMAC-SHA1, pamiętaj, by zapisać token tokena dostępu obok wartości tokena w bazie danych. W przeciwnym razie nie będziesz w stanie poprawnie zrekonstruować parametrów protokołu OAuth do późniejszego użycia.

Używanie tokena dostępu

Gdy otrzymasz token dostępu, użyj standardowej wywołania biblioteki klienta interfejsów API danych Google, aby wejść w interakcję z usługą. Biblioteka zajmie się podpisywaniem żądań i umieszczaniem odpowiedniego nagłówka autoryzacji. Token użytkownika jest zazwyczaj odczytywany z pliku cookie lub bazy danych. Te przykłady pokazują, jak odtworzyć parametry OAuth i wywoływać bibliotekę biblioteki klienta.

Java

Jeśli używasz HMAC-SHA1:

  GoogleOAuthParameters oauthParameters = new GoogleOAuthParameters();
  oauthParameters.setOAuthConsumerKey(CONSUMER_KEY);
  oauthParameters.setOAuthConsumerSecret(CONSUMER_SECRET);
  oauthParameters.setOAuthToken(ACCESS_TOKEN);
  oauthParameters.setOAuthTokenSecret(TOKEN_SECRET);

  DocsService client = new DocsService("yourCompany-YourAppName-v1");
  client.setOAuthCredentials(oauthParameters, new OAuthHmacSha1Signer());

  URL feedUrl = new URL("https://docs.google.com/feeds/default/private/full");
  DocumentListFeed resultFeed = client.getFeed(feedUrl, DocumentListFeed.class);
  for (DocumentListEntry entry : resultFeed.getEntries()) {
    System.out.println(entry.getTitle().getPlainText());
  }

Różnica w RSA-SHA1 polega na tym, że nie musisz ustawiać obiektu tajnego tokena dostępu, a tworzenie obiektu podpisującego jest inne:

  GoogleOAuthParameters oauthParameters = new GoogleOAuthParameters();
  oauthParameters.setOAuthConsumerKey(CONSUMER_KEY);
  oauthParameters.setOAuthConsumerSecret(CONSUMER_SECRET);
  oauthParameters.setOAuthToken(ACCESS_TOKEN);

  PrivateKey privKey = getPrivateKey("/path/to/your/rsakey.pk8");  // See above for the defintion of getPrivateKey()

  DocsService client = new DocsService("yourCompany-YourAppName-v1");
  client.setOAuthCredentials(oauthParameters, new OAuthRsaSha1Signer(privKey));

  URL feedUrl = new URL("https://docs.google.com/feeds/default/private/full");
  DocumentListFeed resultFeed = client.getFeed(feedUrl, DocumentListFeed.class);
  for (DocumentListEntry entry : resultFeed.getEntries()) {
    System.out.println(entry.getTitle().getPlainText());
  }

PHP

require_once 'Zend/Gdata/Docs.php';

if (isset($_SESSION['ACCESS_TOKEN'])) {
  $accessToken = unserialize($_SESSION['ACCESS_TOKEN']);
} else {
  exit;
}


/*  Or, you could set an existing token (say one stored from your database). For HMAC-SHA1:
$accessToken = new Zend_Oauth_Token_Access();
$accessToken->setToken('1/AQfoI-qJDqkvvkf216Gc2g');
$accessToken->setTokenSecret('2c26GLW250tZiQ');
*/

$httpClient = $accessToken->getHttpClient($oauthOptions);
$client = new Zend_Gdata_Docs($httpClient, "yourCompany-YourAppName-v1");

// Retrieve user's list of Google Docs
$feed = $client->getDocumentListFeed();
foreach ($feed->entries as $entry) {
  echo "$entry->title\n";
}

Python

W tym fragmencie zakładamy, że masz już pobrany token dostępu (przy użyciu identyfikatora HMAC-SHA1) i wycofujesz ten klucz lub tajny token do późniejszego użycia.

Jeśli używasz nowszych klas w wersji 2.0 lub nowszej opartych na GDClient, użyj:

client = gdata.docs.client.DocsClient(source='yourCo-yourAppName-v1')
client.auth_token = gdata.gauth.OAuthHmacToken(CONSUMER_KEY, CONSUMER_SECRET, TOKEN,
                                               TOKEN_SECRET, gdata.gauth.ACCESS_TOKEN)
feed = client.GetDocList()
for entry in feed.entry:
  print entry.title.text

Jeśli używasz starszych klas 1.0 opartych na GDataService, użyj:

client = gdata.docs.service.DocsService(source='yourCompany-YourAppName-v1')
client.SetOAuthInputParameters(SIG_METHOD, CONSUMER_KEY, consumer_secret=CONSUMER_SECRET)

# the token key and secret should be recalled from your database
client.SetOAuthToken(gdata.auth.OAuthToken(key=TOKEN, secret=TOKEN_SECRET))

feed = client.GetDocumentListFeed()
for entry in feed.entry:
  print entry.title.text

.NET

Jeśli używasz HMAC-SHA1:

OAuthParameters parameters = new OAuthParameters() {
  ConsumerKey = CONSUMER_KEY,
  ConsumerSecret = CONSUMER_SECRET,
  Token = ACCESS_TOKEN,
  TokenSecret = TOKEN_SECRET
}

GOAuthRequestFactory requestFactory = new GOAuthRequestFactory("writely", APPLICATION_NAME, parameters);

DocsService service = new DocsService(APPLICATION_NAME);
service.RequestFactory = requestFactory;

DocumentsListQuery query = new DocumentsListQuery();
DocumentsFeed feed = service.Query(query);
foreach (DocumentEntry entry in feed.Entries) {
  Console.WriteLine(entry.Title.Text);
}

Różnica w RSA-SHA1 polega na tym, że nie musisz ustawiać obiektu tajnego tokena dostępu, a tworzenie obiektu podpisującego jest inne:

RSA-SHA1 is not supported yet.

Dodatkowe trzyetapowe zasoby i przykłady protokołu OAuth

Przykłady protokołu OAuth na blogu Google Data API – wskazówki
Artykuł: Używanie protokołu OAuth z interfejsami API danych Google
Biblioteka klienta Pythona przykład
Biblioteka klienta Pythona Przykład Google App Engine
Przykładowa biblioteka klienta Java
Biblioteka klienta Java Przykład Google App Engine
Biblioteka klienta klienta Zend PHP przykład
Dokumentacja uwierzytelniania OAuth do aplikacji internetowych.
Dokumentacja protokołu OAuth.net

Powrót do góry

Dwuetapowa autoryzacja OAuth

Dwuetapowa autoryzacja OAuth umożliwia zaufanym aplikacjom uzyskiwanie dostępu do danych Google użytkowników bez ich bezpośredniego udziału. Dwie grupy kluczy mogą korzystać z dwuetapowej autoryzacji OAuth:

Administratorzy domen G Suite: administratorzy mogą tworzyć skrypty i aplikacje niestandardowe do zarządzania danymi użytkowników w domenie przy użyciu interfejsów API danych Google. Aby dowiedzieć się więcej o zarządzaniu kluczem i tajnym kluczem, które są powiązane z Twoją domeną G Suite, oraz przyznawaniu globalnej kontroli dostępu, zobacz Zarządzanie kluczem i kluczem tajnym OAuth.

Zewnętrzni dostawcy oprogramowania: w ramach integracji z G Suite dostawcy mogą oferować aplikacje korzystające z dwuetapowej autoryzacji OAuth. Aplikacje innych firm można przyznać na stronie Zarządzanie interfejsem API klienta lub instalując z G Suite Marketplace.

Token dostępu nie jest wymagany zgodnie ze zwykłym procesem autoryzacji (nazywanym też trzyetapową autoryzacją OAuth).

Poniższe przykłady biblioteki klienta pokazują, jak skonfigurować klienta do korzystania z 2-etapowej autoryzacji OAuth za pomocą HMAC-SHA1.

Java

import com.google.gdata.client.docs.*;
import com.google.gdata.client.authn.oauth.*;

String CONSUMER_KEY = "example.com";
String CONSUMER_SECRET = "abc123doremi";

GoogleOAuthParameters oauthParameters = new GoogleOAuthParameters();
oauthParameters.setOAuthConsumerKey(CONSUMER_KEY);
oauthParameters.setOAuthConsumerSecret(CONSUMER_SECRET);

DocsService client = new DocsService("yourCompany-YourAppName-v1");
client.setOAuthCredentials(oauthParameters, new OAuthHmacSha1Signer());

// Retrieve user's list of Google Docs
String user = "any.user@anydomain.com";
URL feedUrl = new URL("https://docs.google.com/feeds/default/private/full" +
                      "?xoauth_requestor_id=" + user);

DocumentListFeed resultFeed = client.getFeed(feedUrl, DocumentListFeed.class);
for (DocumentListEntry entry : resultFeed.getEntries()) {
  System.out.println(entry.getTitle().getPlainText());
}

PHP

require_once 'Zend/Oauth/Consumer.php';
require_once 'Zend/Gdata/Docs.php';

$CONSUMER_KEY = 'example.com';
$CONSUMER_SECRET = 'abc123doremi';
$USER = 'any.user@anydomain.com';

$oauthOptions = array(
    'requestScheme' => Zend_Oauth::REQUEST_SCHEME_HEADER,
    'version' => '1.0',
    'signatureMethod' => 'HMAC-SHA1',
    'consumerKey' => $CONSUMER_KEY,
    'consumerSecret' => $CONSUMER_SECRET
);

$consumer = new Zend_Oauth_Consumer($oauthOptions);
$token = new Zend_Oauth_Token_Access();
$httpClient = $token->getHttpClient($oauthOptions);

$client = new Zend_Gdata_Docs($httpClient);

// Retrieve user's list of Google Docs
$feed = $client->getDocumentListFeed('https://docs.google.com/feeds/default/private/full?xoauth_requestor_id=' . urlencode($USER));
foreach ($feed->entries as $entry) {
  echo "$entry->title\n";
}

Python

Jeśli używasz nowszych klas w wersji 2.0 lub nowszej opartych na GDClient, użyj:

import gdata.gauth
import gdata.docs.client

CONSUMER_KEY = 'example.com'
CONSUMER_SECRET = 'abc123doremi'
requestor_id = 'any.user@anydomain.com'

client = gdata.docs.client.DocsClient(source='yourCompany-YourAppName-v1')
client.auth_token = gdata.gauth.TwoLeggedOAuthHmacToken(
    CONSUMER_KEY, CONSUMER_SECRET, requestor_id)

# Retrieve user's list of Google Docs
feed = client.GetDocList()
for entry in feed.entry:
  print entry.title.text

Jeśli używasz starszych klas 1.0 opartych na GDataService, użyj:

import gdata.auth
import gdata.docs.service

CONSUMER_KEY = 'example.com'
CONSUMER_SECRET = 'abc123doremi'
SIG_METHOD = gdata.auth.OAuthSignatureMethod.HMAC_SHA1

requestor_id = 'any.user@anydomain.com'

client = gdata.docs.service.DocsService(source='yourCompany-YourAppName-v1')
client.SetOAuthInputParameters(SIG_METHOD, CONSUMER_KEY, consumer_secret=CONSUMER_SECRET,
                               two_legged_oauth=True, requestor_id=requestor_id)

# Retrieve user's list of Google Docs
feed = client.GetDocumentListFeed()
for entry in feed.entry:
  print entry.title.text

# Change to another user on your domain
client.GetOAuthInputParameters().requestor_id = 'another.user@example.com'

.NET

using Google.GData.Client;
using Google.GData.Documents;

// Create an OAuth factory to use
GOAuthRequestFactory requestFactory = new GOAuthRequestFactory("writely", "yourCompany-YourAppName-v1");
requestFactory.ConsumerKey = "example.com";
requestFactory.ConsumerSecret = "abc123doremi";

String user = "any.user@anydomain.com";

DocumentsService client = new DocumentsService("yourCompany-YourAppName-v1");
client.RequestFactory = requestFactory;

// Retrieve user's list of Google Docs
DocumentsListQuery query = new DocumentsListQuery();
query.Uri = new OAuthUri("https://docs.google.com/feeds/default/private/full", user, requestFactory.ConsumerKey);

DocumentsFeed feed = client.Query(query);

foreach (DocumentEntry entry in feed.Entries)
{
  Console.WriteLine(entry.Title.Text);
}

Dodatkowe dwuetapowe zasoby i przykłady protokołu OAuth

Dwuetapowe przykłady protokołu OAuth na blogu Google Data API – wskazówki
Biblioteka klienta Java Przykład dwuetapowej autoryzacji OAuth
Biblioteka klienta Pythona TwoLeggedOAuthExample (w przypadku klas client.py) lub 2_legged_oauth (w przypadku usług service.py)
Biblioteka klienta .NET Przykład dwuetapowej autoryzacji OAuth
Dokumentacja dotycząca dwuetapowej autoryzacji OAuth

Generowanie samodzielnie podpisanego klucza prywatnego i certyfikatu publicznego

Klucz prywatny jest używany do generowania podpisu, który musi być dołączony do każdego żądania. Google używa klucza publicznego umieszczonego w certyfikacie do weryfikowania podpisu. Klucz publiczny musi być 1024-bitowym kluczem RSA zakodowanym w certyfikacie X.509 w formacie PEM. Certyfikat należy przesłać do Google w momencie rejestracji.

Poniższe sekcje zawierają przykłady generowania kluczy i certyfikatów za pomocą 2 konkretnych narzędzi: narzędzia OpenSSL i narzędzia Java keytool.

Te przykłady nie dotyczą konkretnych interfejsów API danych Google. Do generowania kluczy możesz używać tych samych narzędzi.

Przykład

Generowanie kluczy przy użyciu OpenSSL

Aby utworzyć parę kluczy RSA i odpowiadający im certyfikat, możesz użyć tego polecenia:

# Generate the RSA keys and certificate
openssl req -x509 -nodes -days 365 -newkey rsa:1024 -sha1 -subj \
  '/C=US/ST=CA/L=Mountain View/CN=www.example.com' -keyout \
  myrsakey.pem -out /tmp/myrsacert.pem

Ostrzeżenie: dodanie parametru -nodes spowoduje utworzenie klucza prywatnego bez hasła. Warto jednak pominąć ten parametr, aby zwiększyć bezpieczeństwo.

Parametr -sha1 określa, że klucz będzie używany do generowania podpisów SHA1.

Parametr -subj określa tożsamość aplikacji, którą reprezentuje certyfikat.

Parametr -keyout określa plik, który zawiera klucze. Ten plik zawiera informacje poufne, więc powinien być chroniony i nie należy go nikomu udostępniać.

Parametr -out określa plik zawierający certyfikat w formacie PEM (który można wysłać do Google podczas rejestracji).

Generowanie kluczy dla klienta .NET

Platforma .NET nie rozpoznaje kluczy ani certyfikatów przechowywanych w formacie PEM. W związku z tym po utworzeniu pliku .pem musisz wykonać dodatkowy krok:

openssl pkcs12 -export -in test_cert.pem -inkey myrsacert.pem -out myrsacert.pfx -name "Testing Certificate"

W tym kroku zostanie wygenerowany plik PFX z klucza prywatnego i certyfikatu. Ten plik można zaimportować do biblioteki klienta .NET, aby podpisywać cyfrowe żądania wysyłane do interfejsów API danych Google.

Generowanie kluczy dla klienta Java

Klient języka Java akceptuje klucze prywatne w formacie PKCS#8. Po wygenerowaniu klucza lub certyfikatu zgodnie z powyższymi instrukcjami utwórz plik .pk8 z wygenerowanego pliku .pem:

openssl pkcs8 -in myrsakey.pem -topk8 -nocrypt -out myrsakey.pk8

Możesz też użyć magazynu kluczy Java i narzędzia keykey do utworzenia pary kluczy RSA i odpowiedniego certyfikatu. Użyj tego polecenia:

# Generate the RSA keys and certificate
keytool -genkey -v -alias Example -keystore ./Example.jks\
  -keyalg RSA -sigalg SHA1withRSA\
  -dname "CN=www.example.com, OU=Engineering, O=My_Company, L=Mountain  View, ST=CA, C=US"\
  -storepass changeme -keypass changeme

Ostrzeżenie: „changeme” nie jest dobrym hasłem. To tylko przykład.

Parametr -dname określa tożsamość aplikacji, którą reprezentuje certyfikat. Parametr -storepass określa hasło, które ma chronić magazyn kluczy. Parametr -keypass określa hasło, które ma chronić klucz prywatny.

Aby zapisać certyfikat w pliku, którego można użyć w narzędziu ManageDomains, użyj tego polecenia:

# Output the public certificate to a file
keytool -export -rfc -keystore ./Example.jks -storepass changeme \
  -alias Example -file mycert.pem

Powrót do góry