OAuth nas bibliotecas de cliente do protocolo de dados do Google

Aviso: esta página é sobre as APIs mais antigas do Google, as APIs Google Data. Ela é relevante apenas para as APIs listadas no diretório de APIs Google Data, muitas das quais foram substituídas por APIs mais recentes. Para informações sobre uma nova API específica, consulte a documentação dela. Para informações sobre como autorizar solicitações com uma API mais recente, consulte Autenticação e autorização de contas do Google.

Este documento descreve como usar as bibliotecas de cliente da API Google Data para se conectar à autenticação OAuth para aplicativos da Web do Google.

A interface do OAuth permite que um aplicativo baseado na Web acesse um serviço do Google em nome de um usuário. Para manter um alto nível de segurança, o OAuth permite que o aplicativo receba um token de acesso sem nunca processar as informações de login da conta do usuário.

As bibliotecas de cliente da API Google Data oferecem métodos para ajudar você a usar o OAuth no seu aplicativo da Web. Especificamente, há métodos para construir e adquirir um token de solicitação, autorizar o token de solicitação e trocar o token de solicitação autorizado por um token de acesso. As bibliotecas também processam os algoritmos de assinatura necessários ao fazer solicitações a um serviço de dados do Google.

Público-alvo

Este documento é destinado a programadores que querem que os aplicativos baseados na Web acessem os serviços do Google em nome dos usuários, usando as bibliotecas de cliente das APIs Google Data.

Este documento pressupõe que você conhece a interface do OAuth e o processo geral para incorporar o OAuth ao seu aplicativo da Web. Para uma descrição completa do protocolo do OAuth, consulte Autenticação OAuth para aplicativos da Web ou a especificação oficial em oauth.net.

Como usar o OAuth de três etapas e as APIs de dados do Google sem as bibliotecas de cliente

Se você quiser que seu aplicativo da Web interaja com um serviço de dados do Google usando o OAuth como método de autorização, tudo o que você precisa saber está em Autenticação OAuth para aplicativos da Web. Não é necessário usar as bibliotecas de cliente das APIs Google Data se você não quiser.

Confira um resumo de como seu aplicativo pode autenticar um usuário usando o OAuth:

O aplicativo faz uma solicitação assinada para buscar um token de solicitação OAuth inicial do endpoint OAuthRequestToken.
O aplicativo redireciona o usuário para o URL OAuthAuthorizeToken adequado para autorizar o token de solicitação.
Ao conceder acesso, o usuário é redirecionado de volta para seu aplicativo (o URL oauth_callback).
O aplicativo envia uma solicitação assinada para fazer upgrade do token de solicitação autorizado para um token de acesso usando o endpoint OAuthGetAccessToken.

As bibliotecas de cliente das APIs de dados do Google simplificam esse processo de autorização ao processar vários detalhes para você. Este documento explica como fazer isso.

Como registrar seu aplicativo da Web

O OAuth exige que todas as chamadas de API sejam assinadas digitalmente. O Google é compatível com os métodos de assinatura HMAC-SHA1 e RSA-SHA1. Para assinar solicitações, seu aplicativo precisa primeiro se registrar no Google. Depois do registro, o Google vai fornecer uma chave de consumidor (e um segredo para uso com HMAC-SHA1) e um lugar para fazer upload de um certificado público.

1. Registrar seu domínio

Siga as etapas descritas em Registro de aplicativos baseados na Web.

2. Criar um par de chave privada / certificado público (opcional)

Se você escolher usar RSA-SHA1 como oauth_signature_method, crie um par de chaves privadas e certificados públicos RSA autoassinados. Consulte Gerar uma chave privada autoassinada e um certificado público (abaixo) para ver exemplos de como fazer isso.

Como trabalhar com o OAuth de três etapas e as APIs de dados do Google: exemplos de bibliotecas de cliente

As seções a seguir mostram exemplos de como usar os métodos da biblioteca de cliente das APIs Google Data para seguir as etapas descritas na seção Como trabalhar com o OAuth da documentação do OAuth. Todos os exemplos neste documento presumem que seu domínio de host do aplicativo seja example.com.

Como determinar o escopo do seu acesso aos dados

Cada serviço do Google define um valor de scope que determina o acesso de um token aos dados do usuário. Os valores de escopo disponíveis estão listados nas Perguntas frequentes sobre dados do Google. Por exemplo, para usar a API Documents List, defina scope como https://docs.google.com/feeds/, conforme listado nas perguntas frequentes.

Observação: defina o valor scope como o URL mais restrito que permite o acesso necessário. Isso reduz a chance de obter e vazar dados pessoais por acidente. Por exemplo, se você quiser acessar o feed particular da lista de documentos do usuário atual, use o escopo https://docs.google.com/feeds/default/private/full em vez de um escopo mais amplo, como https://docs.google.com/feeds/, que fornece acesso a todos os feeds da lista de documentos.

Tokens com vários escopos

Para criar tokens que acessam várias APIs de dados do Google, separe cada escopo com um espaço. O exemplo abaixo cria um token com acesso aos dados do Google Documentos e do Google Agenda de um usuário.

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

Codificação de URL

Os caracteres não ASCII que aparecem em URLs, incluindo dois pontos, barra e espaço, precisam ser codificados para uso em URL para serem transmitidos por HTTP. As bibliotecas de cliente da API Google Data codificam automaticamente os parâmetros de URL para você. Assim, basta usar strings não codificadas por URL ao atribuir valores a parâmetros. Por exemplo, você pode fazer a seguinte atribuição no seu código:

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

Quando você chama a biblioteca de cliente, o parâmetro scope é automaticamente codificado em URL para o seguinte valor:

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

Como buscar um token de solicitação

Java

Para HMAC-SHA1, você precisa de uma maneira de manter o secret do token (obtido na resposta) para criar um objeto de token OAuth que retorna da página de aprovação. Para isso, defina uma variável de sessão ou um 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);

Usando RSA-SHA1, o oauth_token_secret não é usado, então não é necessário manter a chave secreta do token.

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

Usando HMAC-SHA1 como o método de assinatura:

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

Usando RSA-SHA1 como o método de assinatura:

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

Usando HMAC-SHA1 como o método de assinatura:

Se você estiver usando as classes v2.0+ mais recentes com base em GDClient, use:

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

Usando RSA-SHA1 como o método de assinatura:

...

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)

Como alternativa, se você estiver usando as classes v1.0 mais antigas com base em GDataService, as chamadas serão um pouco diferentes:

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)

Usando RSA-SHA1 como o método de assinatura:

...

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

Usando HMAC-SHA1 como o método de assinatura:

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

Usando RSA-SHA1 como o método de assinatura:

RSA-SHA1 is not supported yet.

Autorizar um token de solicitação

Para autorizar um token de solicitação, seu aplicativo precisa redirecionar o usuário para o URL OAuthAuthorizeToken, que pede para ele fazer login na Conta do Google. Para mais informações sobre o URL OAuthAuthorizeToken, consulte a autenticação OAuth completa para aplicativos da Web.

Para criar o URL OAuthAuthorizeToken no seu aplicativo, use o seguinte para cada biblioteca de cliente. Essas amostras se baseiam nos exemplos anteriores.

Depois de criar o URL da página de aprovação, seu aplicativo pode usá-lo de várias maneiras para enviar o usuário ao manipulador OAuthAuthorizeToken. A abordagem mais comum é redirecionar o usuário ou mostrar um link para essa página.

Java

Para HMAC-SHA1:

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

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

Como alternativa, você pode redirecionar para o URL de aprovação:

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

Python

Se você estiver usando as classes v2.0+ mais recentes com base em GDClient, use:

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

Se você estiver usando as classes v1.0 mais antigas com base em GDataService, o processo será um pouco diferente.

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

Extrair o token do URL de callback

Quando o Google redireciona de volta para seu aplicativo, o oauth_token é anexado ao URL "oauth_callback_url" como um parâmetro de consulta. Em seguida, o aplicativo precisa extrair o valor do token do parâmetro de consulta do URL e restabelecer os parâmetros do OAuth.

As bibliotecas de cliente fornecem métodos convenientes para extrair o oauth_token. Esses exemplos se baseiam nos anteriores.

Java

Se você escolheu manter a chave secreta do token no URL de callback (ao usar 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);

A única diferença do RSA-SHA1 é o método de assinatura:

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

Essa etapa não é necessária ao usar a biblioteca PHP.

Python

Se você estiver usando as classes v2.0+ mais recentes com base em GDClient, use:

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

Se você estiver usando as classes v1.0 mais antigas baseadas em GDataService, use:

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'

O processo é semelhante para RSA-SHA1, mas sem o segredo do token:

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

Se você escolheu manter o segredo do token no URL de callback:

OAuthUtil.UpdateOAuthParametersFromCallback(url, parameters);

Como fazer upgrade para um token de acesso

A última etapa da troca de tokens OAuth é fazer upgrade do token de solicitação autorizado para um token de acesso de longa duração usando o URL OAuthGetAccessToken, conforme descrito na documentação completa Autenticação OAuth para aplicativos da Web.

Confira alguns exemplos usando cada uma das bibliotecas de 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

Se você estiver usando as classes v2.0+ mais recentes com base em GDClient, use:

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

Se você estiver usando as classes v1.0 mais antigas baseadas em GDataService, use:

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

Se você estiver usando o gdata.gauth.AeSave() no App Engine, o token e o segredo do token serão armazenados para você no usuário conectado atual.

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

Observação: se você estiver usando HMAC-SHA1, salve o segredo do token de acesso junto com o valor do token no seu banco de dados. Caso contrário, não será possível reconstruir corretamente os parâmetros do OAuth para uso posterior.

Usar um token de acesso

Depois de conseguir um token de acesso, use as chamadas padrão da biblioteca de cliente das APIs de dados do Google para interagir com o serviço. A biblioteca vai assinar as solicitações e incluir o cabeçalho de autorização correto para você. Normalmente, você vai chamar o token do usuário de um cookie ou banco de dados. Esses exemplos demonstram como reconstruir os parâmetros do OAuth e fazer uma chamada de biblioteca de cliente.

Java

Se você estiver usando 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());
  }

A diferença com RSA-SHA1 é que não é necessário definir o segredo do token de acesso, e a construção do objeto de assinatura é diferente:

  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

Este snippet pressupõe que você já buscou um token de acesso (usando HMAC-SHA1) e está chamando a chave/o segredo do token para uso posterior.

Se você estiver usando as classes v2.0+ mais recentes com base em GDClient, use:

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

Se você estiver usando as classes v1.0 mais antigas baseadas em GDataService, use:

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

Se você estiver usando 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);
}

A diferença com RSA-SHA1 é que não é necessário definir o segredo do token de acesso, e a construção do objeto de assinatura é diferente:

RSA-SHA1 is not supported yet.

Outros recursos e exemplos de OAuth de três etapas

Exemplos de OAuth no blog de dicas da API Google Data (em inglês)
Artigo: Como usar o OAuth com as APIs de dados do Google
Exemplo da biblioteca de cliente Python
Biblioteca de cliente Python Exemplo do Google App Engine
Exemplo da biblioteca de cliente Java
Biblioteca de cliente Java Exemplo do Google App Engine
Exemplo da biblioteca de cliente PHP do Zend
Documentação sobre autenticação OAuth para aplicativos da Web
Documentação do OAuth.net

Voltar ao início

OAuth de duas etapas

O OAuth de duas etapas permite que aplicativos confiáveis acessem os dados do Google dos usuários sem envolvimento direto deles. Dois grupos principais podem usar o OAuth de duas etapas:

Administradores de domínio do G Suite:eles podem criar scripts e aplicativos personalizados que gerenciam os dados de usuários do domínio com as APIs Google Data. Para saber como gerenciar a chave e o secret associados ao seu domínio do G Suite e conceder controle de acesso global, consulte "Gerenciar a chave e o secret do OAuth".

Fornecedores de software terceirizados:eles podem oferecer aplicativos que usam o OAuth de duas etapas para se integrar ao G Suite. O acesso aos aplicativos de terceiros pode ser concedido na página "Gerenciar cliente de API" ou com a instalação pelo G Suite Marketplace.

Um token de acesso não é necessário de acordo com o fluxo de autorização normal (também chamado de OAuth de três etapas).

Os exemplos de biblioteca de cliente a seguir demonstram como configurar o cliente para usar o OAuth de duas etapas com 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

Se você estiver usando as classes v2.0+ mais recentes com base em GDClient, use:

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

Se você estiver usando as classes v1.0 mais antigas baseadas em GDataService, use:

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

Outros recursos e exemplos do OAuth de duas etapas

Exemplos de OAuth de duas etapas no blog de dicas da API Google Data (em inglês)
Exemplo de OAuth de duas etapas da biblioteca de cliente do Java
Biblioteca de cliente Python TwoLeggedOAuthExample (para classes client.py) ou exemplo de OAuth de duas etapas (para classes service.py)
Biblioteca de cliente do .NET Exemplo de OAuth de duas etapas
Documentação do OAuth de duas etapas

Como gerar uma chave privada e um certificado público autoassinados

A chave privada é usada para gerar uma assinatura, que precisa ser incluída em cada solicitação. A chave pública incorporada no certificado é usada pelo Google para verificar a assinatura. A chave pública precisa ser uma chave RSA de 1024 bits codificada em um certificado X.509 no formato PEM. O certificado precisa ser enviado ao Google no momento do registro.

As seções a seguir fornecem exemplos de como gerar chaves e certificados usando duas ferramentas específicas: o utilitário OpenSSL e o utilitário keytool do Java.

Esses exemplos não são específicos das APIs Google Data. Você pode usar os mesmos utilitários para gerar chaves para qualquer finalidade.

Os exemplos pressupõem que sua empresa se chama My_Company e está localizada em Mountain View, Califórnia, EUA, com o nome de domínio example.com.

Gerar chaves usando o OpenSSL

Para criar um par de chaves RSA e o certificado correspondente, use o seguinte comando:

# 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

Aviso: incluir o parâmetro -nodes cria uma chave privada sem uma senha para protegê-la. No entanto, considere omitir esse parâmetro para aumentar a segurança.

O parâmetro -sha1 especifica que a chave será usada para gerar assinaturas SHA1.

O parâmetro -subj especifica a identidade do aplicativo que o certificado representa.

O parâmetro -keyout especifica o arquivo que vai conter as chaves. Esse arquivo contém informações sensíveis e precisa ser protegido e não compartilhado com ninguém.

O parâmetro -out especifica o arquivo que vai conter o certificado no formato PEM (que pode ser enviado ao Google durante o registro).

Como gerar chaves para o cliente .NET

O .NET Framework não entende chaves ou certificados armazenados no formato PEM. Portanto, é necessário realizar uma etapa extra depois de criar o arquivo .pem:

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

Esta etapa gera um arquivo PFX da sua chave privada e do certificado. Esse arquivo pode ser importado para a biblioteca de cliente .NET para assinar digitalmente as solicitações feitas às APIs de dados do Google.

Como gerar chaves para o cliente Java

O cliente Java aceita chaves privadas no formato PKCS#8. Depois de gerar uma chave/certificado usando as instruções acima, crie um arquivo .pk8 com o arquivo .pem gerado:

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

Como alternativa, use o keystore do Java e o utilitário keytool para criar um par de chaves RSA e o certificado correspondente. Use o comando a seguir:

# 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

Atenção: "changeme" não é uma boa senha. Este é apenas um exemplo.

O parâmetro -dname especifica a identidade do aplicativo que o certificado representa. O parâmetro -storepass especifica a senha para proteger o keystore. O parâmetro -keypass especifica a senha para proteger a chave privada.

Para gravar o certificado em um arquivo que pode ser usado na ferramenta ManageDomains, use o seguinte comando:

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

Voltar ao início

OAuth nas bibliotecas de cliente do protocolo de dados do Google Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Público-alvo

Como usar o OAuth de três etapas e as APIs de dados do Google sem as bibliotecas de cliente

Como registrar seu aplicativo da Web

1. Registrar seu domínio

2. Criar um par de chave privada / certificado público (opcional)

Como trabalhar com o OAuth de três etapas e as APIs de dados do Google: exemplos de bibliotecas de cliente

Como determinar o escopo do seu acesso aos dados

Tokens com vários escopos

Codificação de URL

Como buscar um token de solicitação

Java

PHP

Python

.NET

Autorizar um token de solicitação

Java

PHP

Python

.NET

Extrair o token do URL de callback

Java

PHP

Python

.NET

Como fazer upgrade para um token de acesso

Java

PHP

Python

.NET

Usar um token de acesso

Java

PHP

Python

.NET

Outros recursos e exemplos de OAuth de três etapas

OAuth de duas etapas

Java

PHP

Python

.NET

Outros recursos e exemplos do OAuth de duas etapas

Como gerar uma chave privada e um certificado público autoassinados

Gerar chaves usando o OpenSSL

Como gerar chaves para o cliente .NET

Como gerar chaves para o cliente Java

OAuth nas bibliotecas de cliente do protocolo de dados do Google