Diese Seite wurde von der Cloud Translation API übersetzt.

OAuth in den Google Data Protocol-Clientbibliotheken

Warnung: Diese Seite bezieht sich auf die älteren Google Data APIs. Sie ist nur für die APIs relevant, die im Verzeichnis der Google Data APIs aufgeführt sind. Viele davon wurden durch neuere APIs ersetzt. Informationen zu einer bestimmten neuen API finden Sie in der Dokumentation der neuen API. Informationen zum Autorisieren von Anfragen mit einer neueren API finden Sie unter Authentifizierung und Autorisierung von Google-Konten.

In diesem Dokument wird beschrieben, wie Sie die Google Data API-Clientbibliotheken verwenden, um eine Verbindung zur OAuth-Authentifizierung für Webanwendungen von Google herzustellen.

Über die OAuth-Schnittstelle kann eine webbasierte Anwendung im Namen eines Nutzers auf einen Google-Dienst zugreifen. OAuth sorgt dafür, dass die Anwendung ein Zugriffstoken erhält, ohne die Anmeldedaten des Nutzerkontos verarbeiten zu müssen.

Die Google Data API-Clientbibliotheken bieten Methoden zur Verwendung von OAuth in Ihrer Webanwendung. Insbesondere gibt es Methoden zum Erstellen eines Anfragetokens, zum Autorisieren des Anfragetokens und zum Ersetzen des autorisierten Anfragetokens durch ein Zugriffstoken. Die Bibliotheken verarbeiten auch die erforderlichen Signaturalgorithmen, wenn Sie Anfragen an einen Google Data-Dienst stellen.

Zielgruppe

Dieses Dokument richtet sich an Programmierer, die ihre webbasierten Anwendungen im Auftrag von Nutzern über die Google Data APIs-Client-Bibliotheken auf Google-Dienste zugreifen möchten.

In diesem Dokument wird davon ausgegangen, dass Sie mit der OAuth-Benutzeroberfläche und dem allgemeinen Verfahren zum Einbinden von OAuth in Ihre Webanwendung vertraut sind. Eine vollständige Beschreibung des OAuth-Protokolls finden Sie unter OAuth-Authentifizierung für Webanwendungen oder in der offiziellen Spezifikation unter oauth.net.

Dreibeiniges OAuth und Google Data APIs ohne Clientbibliotheken verwenden

Wenn Ihre Webanwendung mit OAuth als Autorisierungsmethode mit einem Google Data-Dienst interagieren soll, finden Sie alle Informationen dazu in OAuth-Authentifizierung für Webanwendungen. Wenn Sie das nicht möchten, müssen Sie die Google Data APIs-Clientbibliotheken nicht verwenden.

Im Folgenden finden Sie einen Überblick darüber, wie Ihre Anwendung einen Nutzer mit OAuth authentifizieren kann:

Ihre Anwendung stellt eine signierte Anfrage zum Abrufen eines ersten OAuth-Anfragetokens vom Endpunkt OAuthRequestToken.
Ihre Anwendung leitet den Nutzer zur entsprechenden OAuthAuthorizeToken-URL weiter, um das Anfragetoken zu autorisieren.
Nach dem Gewähren des Zugriffs wird der Nutzer wieder zu Ihrer Anwendung weitergeleitet (URL oauth_callback).
Ihre Anwendung sendet eine signierte Anfrage, um das autorisierte Anfragetoken mithilfe des OAuthGetAccessToken-Endpunkts auf ein Zugriffstoken zu aktualisieren.

Die Google Data APIs-Clientbibliotheken vereinfachen diesen Autorisierungsprozess, indem sie verschiedene Details für Sie verarbeiten. In diesem Dokument wird die Vorgehensweise beschrieben.

Webanwendung registrieren

OAuth erfordert, dass alle API-Aufrufe digital signiert sind. Google unterstützt die Signaturmethoden HMAC-SHA1 und RSA-SHA1. Damit Sie Anfragen signieren können, muss sich Ihre Anwendung bei Google registrieren. Sobald Sie sich registriert haben, erhalten Sie von Google einen Verbraucherschlüssel (und ein Geheimnis für die Verwendung mit HMAC-SHA1) sowie einen Ort zum Hochladen eines öffentlichen Zertifikats.

1. Domain registrieren

Führen Sie die Schritte unter Registrierung für webbasierte Anwendungen aus.

2. Paar aus privatem Schlüssel und öffentlichem Zertifikat erstellen (optional)

Wenn Sie RSA-SHA1 als oauth_signature_method verwenden, müssen Sie ein selbstsigniertes RSA-Paar aus privatem Schlüssel und öffentlichem Zertifikat erstellen. Beispiele finden Sie unten im Abschnitt Selbstsignierten privaten Schlüssel und öffentlichen Zertifikaten generieren.

Mit dreibeinigem OAuth und den Google Data APIs arbeiten: Beispiele für Clientbibliotheken

In den folgenden Abschnitten werden Beispiele für die Verwendung der Clientbibliotheksmethoden der Google Data APIs anhand der Schritte beschrieben, die im Abschnitt Mit OAuth arbeiten der OAuth-Dokumentation beschrieben werden. In allen Beispielen in diesem Dokument wird davon ausgegangen, dass die Hostdomain Ihrer Anwendung example.com ist.

Umfang des Datenzugriffs ermitteln

Jeder Google-Dienst definiert einen scope-Wert, der den Zugriff eines Tokens auf die Daten des Nutzers bestimmt. Die verfügbaren Werte für den Umfang finden Sie in den häufig gestellten Fragen zu Google-Daten. Wenn Sie beispielsweise die Documents List API verwenden möchten, legen Sie scope auf https://docs.google.com/feeds/ fest, wie in den FAQs aufgeführt.

Hinweis: Setzen Sie den Wert scope auf die URL mit der engsten URL, die den von Ihnen benötigten Zugriff erlaubt. So verringern Sie die Wahrscheinlichkeit, dass personenbezogene Daten versehentlich abgerufen und offengelegt werden. Wenn Sie beispielsweise auf den privaten Dokumentlistenfeed des aktuellen Nutzers zugreifen möchten, verwenden Sie den Bereich https://docs.google.com/feeds/default/private/full anstelle eines größeren Bereichs wie https://docs.google.com/feeds/, wodurch der Zugriff auf alle Dokumentlistenfeeds ermöglicht wird.

Tokens mit mehreren Bereichen

Trennen Sie zum Erstellen von Tokens für den Zugriff auf mehrere Google Data APIs die einzelnen Bereiche durch ein Leerzeichen. Im folgenden Beispiel wird ein Token mit Zugriff auf die Google Docs- und Google Kalender-Daten eines Nutzers erstellt.

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

URL-Codierung

Nicht-ASCII-Zeichen in URLs, einschließlich Doppelpunkt, Schrägstrich und Leerzeichen, müssen URL-codiert werden, damit sie über HTTP übertragen werden können. Google Data API-Clientbibliotheken codieren automatisch Parameter für die URL-Codierung, sodass Sie einfach nicht URL-codierte Strings verwenden können, wenn Sie den Parametern Werte zuweisen. Sie können beispielsweise die folgende Zuweisung im Code vornehmen:

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

Wenn Sie die Clientbibliothek aufrufen, wird der Parameter scope dann automatisch auf den folgenden Wert URL-codiert:

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

Anfragetoken abrufen

Java

Für HMAC-SHA1 benötigen Sie eine Möglichkeit, das Token-Secret beizubehalten (in der Antwort erhalten), um ein OAuth-Token-Objekt zu erstellen, das von der Genehmigungsseite zurückgegeben wird. Legen Sie dazu eine Sitzungsvariable oder ein Cookie fest.

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

Mit RSA-SHA1 wird oauth_token_secret nicht verwendet, sodass das Token-Secret nicht beibehalten werden muss.

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

HMAC-SHA1 als Signaturmethode verwenden:

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

RSA-SHA1 als Signaturmethode verwenden:

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

HMAC-SHA1 als Signaturmethode verwenden:

Wenn Sie die neueren Klassen, Version 2.0 oder höher, basierend auf GDClient verwenden, verwenden Sie:

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

RSA-SHA1 als Signaturmethode verwenden:

...

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)

Wenn Sie die älteren v1.0-Klassen verwenden, die auf GDataService basieren, unterscheiden sich die Aufrufe etwas:

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)

RSA-SHA1 als Signaturmethode verwenden:

...

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

HMAC-SHA1 als Signaturmethode verwenden:

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

RSA-SHA1 als Signaturmethode verwenden:

RSA-SHA1 is not supported yet.

Anfragetoken autorisieren

Zum Autorisieren eines Anfrage-Tokens muss der Nutzer von der Anwendung zur URL OAuthAuthorizeToken weitergeleitet werden. Dadurch wird er aufgefordert, sich in seinem Google-Konto anzumelden. Weitere Informationen zur OAuthAuthorizeToken-URL finden Sie in der vollständigen OAuth-Authentifizierung für Webanwendungen.

Zum Erstellen der OAuthAuthorizeToken-URL in Ihrer Anwendung verwenden Sie für jede Clientbibliothek Folgendes: Diese Beispiele basieren auf den vorherigen Beispielen.

Nachdem Sie die URL der Genehmigungsseite erstellt haben, kann sie von Ihrer Anwendung auf verschiedene Arten verwendet werden, um den Nutzer an den OAuthAuthorizeToken-Handler zu senden. Der häufigste Ansatz besteht darin, den Nutzer weiterzuleiten oder einen Link zu dieser Seite anzuzeigen.

Token aus der Callback-URL extrahieren

Wenn Google zu Ihrer Anwendung zurückgeleitet wird, wird oauth_token als Suchparameter an die URL „oauth_callback_url“ angehängt. Die Anwendung sollte dann den Tokenwert aus dem URL-Suchparameter extrahieren und die oauth-Parameter neu einrichten.

Die Clientbibliotheken bieten praktische Methoden zum Extrahieren von oauth_token. Diese Beispiele basieren auf den vorherigen Beispielen.

Upgrade auf Zugriffstoken ausführen

Im letzten Schritt des OAuth-Token-Tanzes muss das autorisierte Anfrage-Token mithilfe der URL OAuthGetAccessToken auf ein langlebiges Zugriffstoken aktualisiert werden. Dies wird in der vollständigen Dokumentation zur OAuth-Authentifizierung für Webanwendungen beschrieben.

Im Folgenden finden Sie einige Beispiele für die einzelnen Clientbibliotheken:

Hinweis: Wenn Sie HMAC-SHA1 verwenden, müssen Sie das Token-Geheimnis des Zugriffstokens zusammen mit dem Tokenwert in Ihrer Datenbank speichern. Andernfalls können Sie die oauth-Parameter für die spätere Verwendung nicht ordnungsgemäß rekonstruieren.

Zugriffstoken

Nachdem Sie ein Zugriffstoken erhalten haben, verwenden Sie die Standardaufrufe der Google Data APIs-Clientbibliothek, um mit dem Dienst zu interagieren. Die Bibliothek übernimmt das Signieren der Anfragen und das Einfügen des korrekten Autorisierungsheaders. Normalerweise rufen Sie das Token des Nutzers von einem Cookie oder einer Datenbank ab. Diese Beispiele zeigen, wie die oauth-Parameter rekonstruiert und ein Clientbibliotheksaufruf durchgeführt wird.

Java

Wenn Sie HMAC-SHA1 verwenden:

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

Der Unterschied zu RSA-SHA1 besteht darin, dass Sie das Secret für das Zugriffstoken nicht festlegen müssen und das Signaturobjekt anders erstellt wird.

  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

Bei diesem Snippet wird davon ausgegangen, dass Sie bereits ein Zugriffstoken mit HMAC-SHA1 abgerufen haben und diesen Tokenschlüssel zur späteren Verwendung abrufen.

Wenn Sie die neueren Klassen, Version 2.0 oder höher, basierend auf GDClient verwenden, verwenden Sie:

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

Wenn Sie die älteren v1.0-Klassen basierend auf GDataService verwenden, verwenden Sie:

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

Wenn Sie HMAC-SHA1 verwenden:

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

Der Unterschied zu RSA-SHA1 besteht darin, dass Sie das Secret für das Zugriffstoken nicht festlegen müssen und das Signaturobjekt anders erstellt wird.

RSA-SHA1 is not supported yet.

Zusätzliche dreibeinige OAuth-Ressourcen und Beispiele

OAuth-Beispiele im Google Data API-Tipps-Blog
Artikel: OAuth mit den Google Data APIs verwenden
Beispiel für eine Python-Clientbibliothek
Python-Clientbibliothek Beispiel für Google App Engine
Beispiel für eine Java-Clientbibliothek
Java-Clientbibliothek Google App Engine-Beispiel
Beispiel für die Zend-PHP-Clientbibliothek
Dokumentation zu OAuth-Authentifizierung für Webanwendungen
OAuth.net-Dokumentation

Nach oben

2-legged OAuth

Zweibeiniges OAuth ermöglicht vertrauenswürdigen Anwendungen den direkten Zugriff auf Google-Daten von Nutzern. Zwei Schlüsselgruppen können das zweibeinige OAuth verwenden:

G Suite-Domainadministratoren:Administratoren können Skripts und benutzerdefinierte Anwendungen erstellen, mit denen die Nutzerdaten für ihre Domain über Google Data APIs verwaltet werden. Informationen zum Verwalten des mit Ihrer G Suite-Domain verknüpften Schlüssels und Secrets und zum Gewähren einer globalen Zugriffssteuerung finden Sie unter OAuth-Key und -Secret verwalten.

Drittanbieter-Software: Anbieter können Anwendungen mit zweibeinigem OAuth für die Einbindung in die G Suite anbieten. Der Zugriff für Anwendungen von Drittanbietern kann auf der Seite „API-Client verwalten“ oder über den G Suite Marketplace gewährt werden.

Gemäß dem normalen Autorisierungsablauf (auch als dreibeiniges OAuth bezeichnet) ist kein Zugriffstoken erforderlich.

Die folgenden Beispiele zeigen, wie Sie Ihren Client so einrichten, dass 2 Legged OAuth mit HMAC-SHA1 verwendet wird.

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

Wenn Sie die neueren Klassen, Version 2.0 oder höher, basierend auf GDClient verwenden, verwenden Sie:

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

Wenn Sie die älteren v1.0-Klassen basierend auf GDataService verwenden, verwenden Sie:

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

Zusätzliche zweibeinige OAuth-Ressourcen und Beispiele

Zweibeinige OAuth-Beispiele im Google Data API-Tipps-Blog
Java-Clientbibliothek 2-Legged OAuth-Beispiel
Python-Clientbibliothek TwoLeggedOAuthExample (für client.py-Klassen) oder 2_legged_oauth-Beispiel (für service.py-Klassen)
.NET-Clientbibliothek Beispiel für zweibeiniges OAuth
Dokumentation zu zweibeinigem OAuth

Einen selbst signierenden privaten Schlüssel und ein öffentliches Zertifikat generieren

Der private Schlüssel wird verwendet, um eine Signatur zu generieren, die in jeder Anfrage enthalten sein muss. Der im Zertifikat eingebettete öffentliche Schlüssel wird von Google verwendet, um die Signatur zu überprüfen. Der öffentliche Schlüssel muss ein 1024-Bit-RSA-Schlüssel sein, der in einem X.509-Zertifikat im PEM-Format codiert ist. Das Zertifikat sollte bei der Registrierung an Google gesendet werden.

In den folgenden Abschnitten finden Sie Beispiele zum Generieren von Schlüsseln und Zertifikaten mit zwei bestimmten Tools: dem OpenSSL-Dienstprogramm und dem Java-Dienstprogramm keytool.

Diese Beispiele gelten nicht nur für die Google Data APIs. Sie können mit denselben Dienstprogrammen Schlüssel für beliebige Zwecke generieren.

In den Beispielen wird davon ausgegangen, dass Ihr Unternehmen den Namen „My_Company“ hat und sich in Mountain View, Kalifornien, USA, mit dem Domainnamen „beispiel.de“ befindet.

Schlüssel mit OpenSSL generieren

Mit dem folgenden Befehl können Sie ein Paar RSA-Schlüssel und das entsprechende Zertifikat erstellen:

# 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

Warnung: Wenn Sie den Parameter -nodes angeben, wird zum Schutz ein privater Schlüssel ohne Passwort erstellt. Sie sollten diesen Parameter jedoch aus Sicherheitsgründen weglassen.

Der Parameter -sha1 gibt an, dass der Schlüssel zum Generieren von SHA1-Signaturen verwendet wird.

Der Parameter -subj gibt die Identität der Anwendung an, die das Zertifikat darstellt.

Der Parameter -keyout gibt die Datei an, die die Schlüssel enthält. Diese Datei enthält vertrauliche Informationen und sollte geschützt und an niemanden weitergegeben werden.

Der Parameter -out gibt die Datei an, die das Zertifikat im PEM-Format enthält (das bei der Registrierung an Google gesendet werden kann).

Schlüssel für den .NET-Client generieren

Das .NET Framework kann keine Schlüssel oder Zertifikate verstehen, die im PEM-Format gespeichert sind. Daher ist ein zusätzlicher Schritt erforderlich, nachdem Sie die PEM-Datei erstellt haben:

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

Mit diesem Schritt wird eine PFX-Datei aus Ihrem privaten Schlüssel und Zertifikat erstellt. Diese Datei kann in die .NET-Clientbibliothek importiert werden, um Anfragen an die Google Data APIs digital zu signieren.

Schlüssel für den Java-Client generieren

Der Java-Client akzeptiert private Schlüssel im PKCS#8-Format. Nachdem Sie einen Schlüssel oder ein Zertifikat mithilfe der obigen Anleitung generiert haben, erstellen Sie aus Ihrer generierten PEM-Datei eine PK8-Datei:

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

Alternativ können Sie den Java-Schlüsselspeicher und das Keytool-Dienstprogramm verwenden, um ein RSA-Schlüsselpaar und das entsprechende Zertifikat zu erstellen. Verwenden Sie den folgenden Befehl:

# 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

Warnung: „changeme“ ist kein gutes Passwort, sondern nur ein Beispiel.

Der Parameter -dname gibt die Identität der Anwendung an, die das Zertifikat darstellt. Der Parameter -storepass gibt das Passwort zum Schutz des Schlüsselspeichers an. Der Parameter -keypass gibt das Passwort zum Schutz des privaten Schlüssels an.

Verwenden Sie den folgenden Befehl, um das Zertifikat in eine Datei zu schreiben, die im Tool ManageDomains verwendet werden kann:

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

Nach oben