OAuth dans les bibliothèques clientes du protocole de données Google

Avertissement : Cette page concerne les anciennes API Google, les API Google Data. Elle ne concerne que les API répertoriées dans l'annuaire des API Google Data, dont la plupart ont été remplacées par de nouvelles API. Pour en savoir plus sur une nouvelle API spécifique, consultez sa documentation. Pour en savoir plus sur l'autorisation des requêtes avec une API plus récente, consultez Authentification et autorisation des comptes Google.

Ce document explique comment utiliser les bibliothèques clientes de l'API Google Data pour se connecter à l'authentification OAuth pour les applications Web de Google.

L'interface OAuth permet à une application Web d'accéder à un service Google au nom d'un utilisateur. Afin de maintenir un niveau de sécurité élevé, OAuth permet à l'application d'obtenir un jeton d'accès sans jamais gérer les informations de connexion du compte de l'utilisateur.

Les bibliothèques clientes de l'API Google Data fournissent des méthodes pour vous aider à utiliser OAuth dans votre application Web. Plus précisément, il existe des méthodes pour créer le jeton de requête, autoriser le jeton de requête et échanger le jeton de requête autorisé contre un jeton d'accès. Les bibliothèques gèrent également les algorithmes de signature nécessaires lorsqu'elles envoient des requêtes à un service de données Google.

Audience

Ce document est destiné aux programmeurs qui souhaitent que leurs applications Web accèdent aux services Google pour le compte des utilisateurs à l'aide des bibliothèques clientes des API Google Data.

Dans ce document, nous partons du principe que vous connaissez bien l'interface OAuth, ainsi que le processus général d'intégration d'OAuth dans votre application Web. Pour une description complète du protocole OAuth, consultez la page Authentification OAuth pour les applications Web ou la spécification officielle sur oauth.net.

Utiliser les API OAuth 3.0 et Google Data sans les bibliothèques clientes

Si vous souhaitez que votre application Web interagisse avec un service de données Google en utilisant OAuth comme méthode d'autorisation, vous trouverez toutes les informations nécessaires dans la section Authentification OAuth pour les applications Web. Il n'est pas nécessaire d'utiliser les bibliothèques clientes des API Google Data si vous ne le souhaitez pas.

Voici comment votre application peut authentifier un utilisateur à l'aide du protocole OAuth:

  1. Votre application envoie une requête signée pour récupérer un jeton de requête OAuth initial à partir du point de terminaison OAuthRequestToken.
  2. Votre application redirige l'utilisateur vers l'URL OAuthAuthorizeToken appropriée afin d'autoriser le jeton de requête.
  3. Une fois l'accès autorisé, l'utilisateur est redirigé vers votre application (l'URL oauth_callback).
  4. Votre application envoie une requête signée pour convertir le jeton de requête autorisé en jeton d'accès à l'aide du point de terminaison OAuthGetAccessToken.

Les bibliothèques clientes des API Google Data simplifient ce processus d'autorisation en gérant plusieurs informations à votre place. Ce document explique comment procéder.

Enregistrer votre application Web

OAuth exige que tous les appels d'API soient signés numériquement. Google accepte les méthodes de signature HMAC-SHA1 et RSA-SHA1. Pour signer des requêtes, votre application doit d'abord s'inscrire auprès de Google. Une fois que vous êtes inscrit, Google vous fournit une clé (et un code secret client) à utiliser avec HMAC-SHA1, ainsi qu'un emplacement pour importer un certificat public.

1. Enregistrement de votre domaine

Veuillez suivre la procédure décrite dans Inscription pour les applications Web.

2. Créer une paire clé privée / certificat public (facultatif)

Si vous choisissez d'utiliser RSA-SHA1 comme oauth_signature_method, vous devez créer une paire de clés privées et de certificat public RSA autosignés. Pour savoir comment procéder, consultez la section Générer une clé privée à signature automatique et un certificat public (ci-dessous).

Utilisation de l'authentification OAuth en trois étapes et des API Google Data: exemples de la bibliothèque cliente

Les sections suivantes présentent des exemples d'utilisation des méthodes de la bibliothèque cliente des API Google Data pour suivre les étapes décrites dans la section Utiliser OAuth de la documentation OAuth. Tous les exemples du présent document supposent que le domaine de l'hôte de votre application est example.com.

Déterminer la portée de votre accès aux données

Chaque service Google définit une valeur scope qui détermine l'accès d'un jeton aux données de l'utilisateur. Les valeurs de champ d'application disponibles sont listées dans les questions fréquentes sur les données Google. Par exemple, pour utiliser l'API Documents List, définissez scope sur https://docs.google.com/feeds/, comme indiqué dans les questions fréquentes.

Remarque : Définissez la valeur scope sur l'URL la plus étroite qui autorise l'accès dont vous avez besoin. Vous réduisez ainsi le risque d'obtenir et de divulguer accidentellement des données à caractère personnel. Par exemple, si vous souhaitez accéder au flux privé de la liste de documents de l'utilisateur actuel, utilisez le champ d'application https://docs.google.com/feeds/default/private/full plutôt qu'un champ d'application plus large comme https://docs.google.com/feeds/, qui donne accès à tous les flux de la liste de documents.

Jetons à plusieurs champs d'application

Pour créer des jetons d'accès à plusieurs API Google Data, séparez les champs d'application par un espace. Dans l'exemple ci-dessous, un jeton permet d'accéder aux documents Google Docs et aux données Google Agenda d'un utilisateur.

scope=https://www.google.com/calendar/feeds/ https://docs.google.com/feeds/
Encodage d'URL

Les caractères non-ASCII apparaissant dans les URL, comme les deux points, les barres obliques et les espaces, doivent être encodés en URL pour pouvoir être transmis via HTTP. Les bibliothèques clientes de l'API Google Data encodent automatiquement les paramètres pour vous. Vous pouvez donc simplement utiliser des chaînes non encodées en URL lorsque vous attribuez des valeurs aux paramètres. Par exemple, vous pouvez effectuer l'attribution suivante dans votre code:

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

Lorsque vous appelez la bibliothèque cliente, le paramètre scope est automatiquement encodé en URL dans la valeur suivante : 
https%3a%2f%2fwww.google.com%2fcalendar%2ffeeds%2f+https%3a%2f%2fdocs.google.com%2ffeeds%2f

Récupérer un jeton de requête

Java

Pour HMAC-SHA1, vous avez besoin d'un moyen de conserver le secret du jeton (obtenu dans la réponse) afin de créer un objet de jeton OAuth revenant à partir de la page d'approbation. Pour cela, définissez une variable de session ou un 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);

À l'aide de RSA-SHA1, oauth_token_secret n'est pas utilisé. Il n'est donc pas nécessaire de conserver le secret du jeton.

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

En utilisant HMAC-SHA1 comme méthode de signature:

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

En utilisant RSA-SHA1 comme méthode de signature:

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

En utilisant HMAC-SHA1 comme méthode de signature:

Si vous utilisez les classes v2.0 et ultérieures basées sur GDClient, utilisez:

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

En utilisant RSA-SHA1 comme méthode de signature:

...

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)

Si vous utilisez les anciennes classes v1.0 basées sur GDataService, les appels sont légèrement différents:

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)

En utilisant RSA-SHA1 comme méthode de signature:

...

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

En utilisant HMAC-SHA1 comme méthode de signature:

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

En utilisant RSA-SHA1 comme méthode de signature:

RSA-SHA1 is not supported yet.

Autoriser un jeton de requête

Pour autoriser un jeton de requête, votre application doit rediriger l'utilisateur vers l'URL OAuthAuthorizeToken, qui l'invite à se connecter à son compte Google. Pour en savoir plus sur l'URL OAuthAuthorizeToken, consultez la page Authentification OAuth pour les applications Web.

Pour créer l'URL OAuthAuthorizeToken dans votre application, utilisez ce qui suit pour chaque bibliothèque cliente. Notez que ces exemples s'appuient sur les exemples précédents.

Une fois l'URL de page d'approbation construite, votre application peut l'utiliser de différentes manières pour envoyer l'utilisateur au gestionnaire OAuthAuthorizeToken. L'approche la plus courante consiste à rediriger l'utilisateur ou à afficher un lien vers cette page.

Java

Pour HMAC-SHA1 :

String approvalPageUrl = oauthHelper.createUserAuthorizationUrl(oauthParameters);
System.out.println(approvalPageUrl);

Pour RSA-SHA1 :

String approvalPageUrl = oauthHelper.createUserAuthorizationUrl(oauthParameters);
System.out.println(approvalPageUrl);

PHP

// If on a G Suite domain, use your domain for the hd param (e.g. 'example.com').
$approvalUrl = $consumer->getRedirectUrl(array('hd' => 'default'));
echo "<a href=\"$approvalUrl\">Grant access</a>";

Sinon, vous pouvez simplement rediriger vers l'URL d'approbation:

// If on a G Suite domain, use your domain for the hd param (e.g. 'example.com').
$consumer->redirect(array('hd' => 'default'));

Python

Si vous utilisez les classes v2.0 et ultérieures basées sur GDClient, utilisez:

# req_token is from previous call to client.GetOAuthToken()
domain = None  # If on a G Suite domain, use your domain (e.g. 'example.com').
self.redirect(request_token.generate_authorization_url(google_apps_domain=domain))

Si vous utilisez les anciennes classes v1.0 basées sur GDataService, le processus est un peu différent.

# req_token is from previous call to client.FetchOAuthRequestToken()
oauth_callback_url = 'http://%s/get_access_token' % self.request.host
self.redirect(client.GenerateOAuthAuthorizationURL(callback_url=oauth_callback_url))

.NET

string authorizationUrl = OAuthUtil.CreateUserAuthorizationUrl(parameters);
Console.WriteLine(authorizationUrl);

Extraire le jeton de l'URL de rappel

Lorsque Google effectue une redirection vers votre application, oauth_token est ajouté à l'URL "oauth_callback_url" en tant que paramètre de requête. Votre application doit alors extraire la valeur du jeton de son paramètre de requête d'URL et rétablir les paramètres OAuth.

Les bibliothèques clientes fournissent des méthodes pratiques pour extraire le oauth_token. Ces exemples s'appuient sur les exemples précédents.

Java

Si vous avez choisi de conserver le secret du jeton dans l'URL de rappel (lorsque vous utilisez HMAC-SHA1):

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

GoogleOAuthHelper oauthHelper = new GoogleOAuthHelper(new OAuthHmacSha1Signer());
oauthHelper.getOAuthParametersFromCallback(request.getQueryString(), oauthParameters);

La seule différence avec RSA-SHA1 est la méthode de signature:

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

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

GoogleOAuthHelper oauthHelper = new GoogleOAuthHelper(new OAuthRsaSha1Signer(privKey));
oauthHelper.getOAuthParametersFromCallback(request.getQueryString(), oauthParameters);

PHP

Cette étape n'est pas nécessaire lorsque vous utilisez la bibliothèque PHP.

Python

Si vous utilisez les classes v2.0 et ultérieures basées sur GDClient, utilisez:

# Recall request_token. In Google App Engine, use AeLoad():
# saved_request_token = gdata.gauth.AeLoad('myKey')

request_token = gdata.gauth.AuthorizeRequestToken(saved_request_token, self.request.uri)

Si vous utilisez les anciennes classes v1.0 basées sur GDataService, utilisez:

oauth_token = gdata.auth.OAuthTokenFromUrl(self.request.uri)
if oauth_token:
  oauth_token.secret = # TODO: recall saved request_token and set the token secret here.
  oauth_token.oauth_input_params = gdata.auth.OAuthInputParams(
      gdata.auth.OAuthSignatureMethod.HMAC_SHA1, CONSUMER_KEY, consumer_secret=CONSUMER_SECRET)
 client.SetOAuthToken(oauth_token)
else:
  print 'No oauth_token found in the URL'

Le processus est similaire pour RSA-SHA1, mais sans le secret du jeton:

oauth_token = gdata.auth.OAuthTokenFromUrl(self.request.uri)
if oauth_token:
  oauth_token.oauth_input_params = gdata.auth.OAuthInputParams(
      gdata.auth.OAuthSignatureMethod.RSA_SHA1, CONSUMER_KEY, rsa_key=RSA_KEY)
 client.SetOAuthToken(oauth_token)
else:
  print 'No oauth_token found in the URL'

.NET

Si vous avez choisi de conserver le secret du jeton dans l'URL de rappel:

OAuthUtil.UpdateOAuthParametersFromCallback(url, parameters);

Passer à un jeton d'accès

La dernière étape de la danse du jeton OAuth consiste à convertir le jeton de requête autorisé en jeton d'accès de longue durée à l'aide de l'URL OAuthGetAccessToken, comme décrit dans la documentation complète sur l'authentification OAuth pour les applications Web.

Voici quelques exemples d'utilisation de chaque bibliothèque cliente:

Java

String accessToken = oauthHelper.getAccessToken(oauthParameters);
// You can also pull the OAuth token string from the oauthParameters:
// String accessToken = oauthParameters.getOAuthToken();
System.out.println("OAuth Access Token: " + accessToken);

String accessTokenSecret = oauthParameters.getOAuthTokenSecret();
System.out.println("OAuth Access Token's Secret: " + accessTokenSecret);

PHP

if (!isset($_SESSION['ACCESS_TOKEN'])) {
  if (!empty($_GET) && isset($_SESSION['REQUEST_TOKEN'])) {
    $_SESSION['ACCESS_TOKEN'] = serialize($consumer->getAccessToken($_GET, unserialize($_SESSION['REQUEST_TOKEN'])));
  }
}

Python

Si vous utilisez les classes v2.0 et ultérieures basées sur GDClient, utilisez:

# Upgrade the token and save in the user's datastore
access_token = client.GetAccessToken(request_token)

# If you're using Google App Engine, you can call the AeSave() method to save
# the access token under the current logged in user's account.
#gdata.gauth.AeSave(access_token, token_key)

Si vous utilisez les anciennes classes v1.0 basées sur GDataService, utilisez:

access_token = client.UpgradeToOAuthAccessToken()  # calls SetOAuthToken() for you

Si vous utilisez gdata.gauth.AeSave() sur App Engine, le jeton et son code secret sont stockés sous votre nom d'utilisateur actuel.

.NET

OAuthUtil.GetAccessToken(parameters);

// If you want to extract the OAuth Token/TokenSecret from the OAuthParameters instance:
string accessToken = parameter.Token;
Console.WriteLine("OAuth Access Token: " + accessToken);

string accessTokenSecret = parameter.TokenSecret;
Console.WriteLine("OAuth Access Token's Secret: " + accessTokenSecret);

Remarque : Si vous utilisez HMAC-SHA1, veillez à enregistrer le code secret du jeton d'accès avec la valeur du jeton dans votre base de données. Sinon, vous ne pourrez pas reconstruire correctement les paramètres oauth pour une utilisation ultérieure.

Un jeton d'accès

Après avoir obtenu un jeton d'accès, utilisez les appels standards de la bibliothèque cliente des API Google Data pour interagir avec le service. La bibliothèque se chargera de signer les requêtes et d'inclure l'en-tête d'autorisation approprié pour vous. En général, vous allez rappeler le jeton de l'utilisateur à partir d'un cookie ou d'une base de données. Ces exemples montrent comment reconstruire les paramètres oauth et effectuer un appel de la bibliothèque cliente.

Java

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

La différence avec RSA-SHA1 est que vous n'avez pas besoin de définir le secret du jeton d'accès et que la construction de l'objet signataire est différente:

  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

Dans cet extrait, nous partons du principe que vous avez déjà récupéré un jeton d'accès (à l'aide de HMAC-SHA1) et que vous vous souvenez de sa clé/code secret pour une utilisation ultérieure.

Si vous utilisez les classes v2.0 et ultérieures basées sur GDClient, utilisez:

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

Si vous utilisez les anciennes classes v1.0 basées sur GDataService, utilisez:

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

Si vous utilisez 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);
}

La différence avec RSA-SHA1 est que vous n'avez pas besoin de définir le secret du jeton d'accès et que la construction de l'objet signataire est différente:

RSA-SHA1 is not supported yet.

Autres ressources et exemples OAuth en trois étapes

Haut de page

OAuth en deux étapes

Le protocole OAuth en 2 étapes permet aux applications de confiance d'accéder aux données Google des utilisateurs sans qu'ils ne soient impliqués directement. Deux groupes de clés peuvent utiliser le protocole OAuth à deux acteurs:

Administrateurs de domaine G Suite:les administrateurs peuvent créer des scripts et des applications personnalisées qui gèrent les données utilisateur de leur domaine par le biais des API Google Data. Pour savoir comment gérer la clé et le code secret associés à votre domaine G Suite, et découvrir comment accorder un contrôle d'accès mondial, consultez Gérer la clé et le code secret OAuth.

Fournisseurs de logiciels tiers:les fournisseurs peuvent proposer des applications qui utilisent le protocole OAuth à deux acteurs pour intégrer G Suite. L'accès aux applications tierces peut être accordé sur la page "Gérer l'API cliente" ou à partir de G Suite Marketplace.

Conformément au flux d'autorisation normal (également appelé "OAuth en trois étapes"), un jeton d'accès n'est pas requis.

Les exemples suivants de la bibliothèque cliente montrent comment configurer votre client pour utiliser deux authentifications OAuth à l'aide de 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

Si vous utilisez les classes v2.0 et ultérieures basées sur GDClient, utilisez:

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

Si vous utilisez les anciennes classes v1.0 basées sur GDataService, utilisez:

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

Ressources et exemples OAuth en deux étapes

Générer une clé privée à signature automatique et un certificat public

La clé privée est utilisée pour générer une signature, qui doit être incluse à chaque requête. Google utilise la clé publique intégrée au certificat pour valider la signature. La clé publique doit être une clé RSA de 1 024 bits encodée dans un certificat X.509 au format PEM. Le certificat doit être envoyé à Google au moment de l'enregistrement.

Les sections suivantes fournissent des exemples de génération de clés et de certificats à l'aide de deux outils spécifiques: l'utilitaire OpenSSL et l'utilitaire Java de keytool.

Ces exemples ne sont pas spécifiques aux API Google Data. Vous pouvez utiliser les mêmes utilitaires pour générer des clés, quel que soit votre objectif.

Pour les exemples suivants, nous partons du principe que votre entreprise s'appelle "Mon_Entreprise" et qu'elle se trouve à Mountain View, en Californie (États-Unis), avec le nom de domaine example.com.

Générer des clés avec OpenSSL

Pour créer une paire de clés RSA et le certificat correspondant, vous pouvez utiliser la commande suivante:

# 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

Avertissement: L'inclusion du paramètre -nodes crée une clé privée sans mot de passe. Toutefois, pour plus de sécurité, nous vous conseillons d'omettre ce paramètre.

Le paramètre -sha1 indique que la clé sera utilisée pour générer des signatures SHA1.

Le paramètre -subj spécifie l'identité de l'application que le certificat représente.

Le paramètre -keyout spécifie le fichier qui contiendra les clés. Ce fichier contient des informations sensibles. Il doit être protégé et ne doit être partagé avec personne.

Le paramètre -out spécifie le fichier qui contiendra le certificat au format PEM (qui peut être envoyé à Google lors de l'enregistrement).

Générer des clés pour le client .NET

Le framework .NET ne comprend pas les clés ni les certificats stockés au format PEM. Une étape supplémentaire est donc nécessaire une fois le fichier .pem créé : 

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

Cette étape génère un fichier PFX à partir de votre clé privée et de votre certificat. Ce fichier peut être importé dans la bibliothèque cliente .NET pour signer numériquement les requêtes adressées aux API Google Data.

Générer des clés pour le client Java

Le client Java accepte les clés privées au format PKCS#8. Après avoir généré une clé/un certificat en suivant les instructions ci-dessus, créez un fichier .pk8 à partir du fichier .pem généré:

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

Vous pouvez également utiliser le magasin de clés Java et l'utilitaire keytool pour créer une paire de clés RSA et le certificat correspondant. Exécutez la commande ci-dessous :

# 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

Avertissement : "changeme" n'est pas un bon mot de passe. Il s'agit d'un exemple.

Le paramètre -dname spécifie l'identité de l'application que le certificat représente. Le paramètre -storepass spécifie le mot de passe pour protéger le keystore. Le paramètre -keypass spécifie le mot de passe destiné à protéger la clé privée.

Pour écrire le certificat dans un fichier pouvant être utilisé dans l'outil ManageDomains, utilisez la commande suivante:

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

Haut de page