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 n'est pertinente que pour les API listées dans le répertoire des API Google Data, dont beaucoup ont été remplacées par des API plus récentes. 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 des 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. Pour 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 au compte de l'utilisateur.

Les bibliothèques clientes des 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 construire 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 lors de l'envoi de 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 l'interface OAuth et le processus général d'intégration d'OAuth à votre application Web. Pour obtenir une description complète du protocole OAuth, consultez Authentification OAuth pour les applications Web ou la spécification officielle sur oauth.net.

Utiliser OAuth à trois étapes et les API Google Data sans les bibliothèques clientes

Si vous souhaitez que votre application Web interagisse avec un service de données Google à l'aide d'OAuth comme méthode d'autorisation, vous trouverez toutes les informations nécessaires dans Authentification OAuth pour les applications Web. Vous n'êtes pas obligé d'utiliser les bibliothèques clientes des API Google Data.

Voici un aperçu de la façon dont votre application peut authentifier un utilisateur à l'aide d'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 pour autoriser le jeton de requête.
3. Une fois l'accès accordé, l'utilisateur est redirigé vers votre application (l'URL oauth_callback).
4. Votre application envoie une requête signée pour mettre à niveau 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 divers détails à votre place. Ce document vous 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'enregistrer auprès de Google. Une fois que vous vous êtes inscrit, Google vous fournira une clé client (et un secret à utiliser avec HMAC-SHA1), ainsi qu'un emplacement pour importer un certificat public.

1. Enregistrer votre domaine

Veuillez suivre les étapes décrites 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 devrez créer une paire de clé privée et de certificat public RSA autosignée. Pour obtenir des exemples, consultez Générer une clé privée et un certificat public autosignés (ci-dessous).

Utiliser OAuth à trois niveaux avec les API Google Data : exemples de bibliothèques clientes

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 de ce document partent du principe que le domaine hôte de votre application est example.com.

Déterminer le champ d'application 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 portée 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 précise qui autorise l'accès dont vous avez besoin. Cela réduit le risque d'obtenir et de divulguer des données à caractère personnel par inadvertance. 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 au lieu d'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 à portée multiple

Pour créer des jetons qui accèdent à plusieurs API de données Google, séparez chaque champ d'application par un espace. L'exemple ci-dessous crée un jeton permettant d'accéder aux données Google Docs et 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 qui figurent dans les URL, y compris le deux-points, la barre oblique et l'espace, doivent être encodés en URL pour pouvoir être transmis via HTTP. Les bibliothèques clientes des API de données Google encodent automatiquement les paramètres d'URL 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é au format URL avec 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 devez trouver un moyen de conserver le secret du jeton (obtenu dans la réponse) afin de créer un objet de jeton OAuth renvoyé par la page d'approbation. Pour ce faire, définissez une variable ou un cookie de session.

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

Avec RSA-SHA1, le oauth_token_secret n'est pas utilisé. Il n'est donc pas nécessaire de conserver le code 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

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

Utiliser 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

Utiliser HMAC-SHA1 comme méthode de signature :

Si vous utilisez les classes v2.0+ plus récentes 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')

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

Utiliser 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

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

Utiliser 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 complète sur l'authentification OAuth pour les applications Web.

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

Une fois l'URL de la page d'approbation créée, 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 vers cette page ou à afficher un lien vers celle-ci.

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

Vous pouvez également rediriger simplement 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+ plus récentes 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, la procédure est légèrement différente.

# 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 redirige l'utilisateur vers votre application, le oauth_token est ajouté à l'URL "oauth_callback_url" en tant que paramètre de requête. Votre application doit ensuite 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 (lors de l'utilisation de 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+ plus récentes 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 des jetons 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 chacune des bibliothèques clientes :

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+ plus récentes 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 le secret du jeton seront stockés pour vous sous l'utilisateur actuellement connecté.

.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 secret du jeton d'accès en même temps que 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

Une fois que vous avez obtenu un jeton d'accès, utilisez les appels de bibliothèque cliente des API Google Data standards 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 règle générale, vous récupérez 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 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 de signature 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

Cet extrait suppose que vous avez déjà récupéré un jeton d'accès (à l'aide de HMAC-SHA1) et que vous rappelez cette clé/ce secret de jeton pour une utilisation ultérieure.

Si vous utilisez les classes v2.0+ plus récentes 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 de signature est différente :

RSA-SHA1 is not supported yet.

Autres ressources et exemples OAuth en trois étapes

• Exemples OAuth sur le blog Google Data API Tips
• Article : Utiliser OAuth avec les API Google Data
• Exemple de bibliothèque cliente Python
• Exemple de bibliothèque cliente Python pour Google App Engine
• Exemple de bibliothèque cliente Java
• Exemple Google App Engine de la bibliothèque cliente Java
• Exemple de bibliothèque cliente Zend PHP
• Documentation sur l'authentification OAuth pour les applications Web
• Documentation OAuth.net

Haut de page

OAuth à deux étapes

OAuth à deux facteurs permet aux applications approuvées d'accéder aux données Google des utilisateurs sans leur implication directe. Deux groupes de clés peuvent utiliser OAuth en deux étapes :

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 via les API Google Data. Pour savoir comment gérer la clé et le secret associés à votre domaine G Suite, et comment accorder un contrôle d'accès global, consultez Gérer la clé et le secret OAuth.

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

Un jeton d'accès n'est pas requis dans le flux d'autorisation normal (également appelé OAuth en trois étapes).

Les exemples de bibliothèque cliente suivants montrent comment configurer votre client pour utiliser OAuth à deux identifiants avec 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 = "[e-mail]";
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 = '[e-mail]';

$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+ plus récentes basées sur GDClient, utilisez :

import gdata.gauth
import gdata.docs.client

CONSUMER_KEY = 'example.com'
CONSUMER_SECRET = 'abc123doremi'
requestor_id = '[e-mail]'

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 = '[e-mail]'

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 = '[e-mail]'

.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 = "[e-mail]";

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 supplémentaires sur OAuth en deux étapes

• Exemples d'OAuth à deux étapes sur le blog Google Data API Tips
• Exemple OAuth à deux identifiants de la bibliothèque cliente Java
• Bibliothèque cliente Python TwoLeggedOAuthExample (pour les classes client.py) ou exemple 2_legged_oauth (pour les classes service.py)
• Exemple OAuth à deux étapes de la bibliothèque cliente .NET
• Documentation sur OAuth en deux étapes

Générer une clé privée et un certificat public autosignés

La clé privée permet de générer une signature, qui doit être incluse dans 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 keytool de Java.

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 à n'importe quelle fin.

Les exemples supposent que votre entreprise s'appelle My_Company, qu'elle est située à Mountain View, en Californie (États-Unis), et que son nom de domaine est example.com.

Générer des clés à l'aide d'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 pour la protéger. Toutefois, pour plus de sécurité, vous pouvez envisager d'omettre ce paramètre.

Le paramètre -sha1 spécifie 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 représente le certificat.

Le paramètre -keyout spécifie le fichier qui contiendra les clés. Ce fichier contient des informations sensibles. Vous devez le protéger et ne le partager 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 reconnaît pas les clés ni les certificats stockés au format PEM. Par conséquent, une étape supplémentaire est 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 envoyé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 suivante :

# 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 simplement d'un exemple.

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

Pour écrire le certificat dans un fichier pouvant être utilisé dans l'outil ManageDomains, exécutez 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