Esta página foi traduzida pela API Cloud Translation.

OAuth nas bibliotecas de cliente do protocolo de dados do Google

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

Neste documento, descrevemos 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 precisar lidar com as informações de login da conta do usuário.

As bibliotecas de cliente da API Google Data fornecem métodos para ajudar você a usar o OAuth no seu aplicativo da Web. Especificamente, existem métodos para construir a aquisição de 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 para um serviço de dados do Google.

Público-alvo

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

Neste documento, presumimos que você conheça a interface do OAuth e o processo geral para incorporá-lo ao seu aplicativo da Web. Para uma descrição completa do protocolo OAuth, consulte Autenticação do OAuth para aplicativos da Web ou a especificação oficial em oauth.net.

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 do OAuth para aplicativos da Web. Não é necessário usar as bibliotecas de cliente das APIs de dados do Google se você não quiser.

Veja um resumo de como o 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.
Seu aplicativo redireciona o usuário para o URL OAuthAuthorizeToken apropriado para autorizar o token de solicitação.
Ao conceder acesso, o usuário é redirecionado novamente 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 cliente das APIs de dados do Google simplificam esse processo de autorização ao lidar com vários detalhes para você. Veja neste documento como fazer isso.

Como registrar seu aplicativo da Web

O OAuth exige que todas as chamadas de API sejam assinadas digitalmente. O Google oferece suporte aos métodos de assinatura HMAC-SHA1 e RSA-SHA1. Para assinar solicitações, primeiro seu aplicativo precisa se registrar no Google. Depois que você se registrar, o Google fornecerá uma chave do consumidor e um secret para uso com HMAC-SHA1. Além disso, fornecerá um local para fazer upload de um certificado público.

1. Como registrar seu domínio

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

2. Como criar uma chave privada / par de certificado público (opcional)

Se você optar por usar RSA-SHA1 como oauth_signature_method, precisará criar uma chave privada RSA de assinatura automática e um par de certificados públicos. Consulte Como gerar uma chave privada de assinatura própria 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 da biblioteca de cliente

As seções a seguir mostram exemplos de como usar os métodos da biblioteca de cliente das APIs de dados do Google 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 o domínio do host do seu aplicativo é example.com.

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 do escopo disponível estão listados nas perguntas frequentes sobre dados do Google. Por exemplo, para usar a API Documents List, defina o 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 diminui a chance de coletar e vazar dados pessoais acidentalmente. Por exemplo, se você quiser acessar o feed de lista de documentos particular 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 acessem várias APIs de dados do Google, separe cada escopo com um caractere de espaço. O exemplo abaixo cria um token com acesso aos dados do Google Docs e ao 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 nos URLs, incluindo dois-pontos, barra e espaço, precisam ser codificados em URL para serem transmitidos por HTTP. As bibliotecas clientes da API de dados do Google codificam parâmetros automaticamente por URL para que você possa simplesmente usar strings não codificadas de URL ao atribuir valores a parâmetros. Por exemplo, é possível fazer a seguinte atribuição no 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 é codificado automaticamente no 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 o HMAC-SHA1, você precisa de uma forma de manter o secret do token (recebido na resposta) para criar um objeto de token OAuth retornado na página de aprovação. Para isso, defina um cookie ou variável de sessão.

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. Portanto, não é necessário manter o secret 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

Como usar HMAC-SHA1 como 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))));
}

Como usar RSA-SHA1 como 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

Como usar HMAC-SHA1 como método de assinatura:

Se você estiver usando as classes mais recentes da v2.0 ou posterior com base no 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')

Como usar RSA-SHA1 como 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 mais antigas da v1.0 com base no GDataService, as chamadas vão ser 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)

Como usar RSA-SHA1 como 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

Como usar HMAC-SHA1 como 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);

Como usar RSA-SHA1 como método de assinatura:

RSA-SHA1 is not supported yet.

Como autorizar um token de solicitação

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

Para criar o URL OAuthAuthorizeToken no seu aplicativo, use o código abaixo para cada biblioteca de cliente. Esses exemplos se baseiam nos exemplos anteriores.

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

Como 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. Seu aplicativo deve extrair o valor do token do parâmetro de consulta de URL e restabelecer os parâmetros OAuth.

As bibliotecas de cliente oferecem métodos de conveniência para extrair o oauth_token. Esses exemplos são baseados nos exemplos anteriores.

Como fazer upgrade para um token de acesso

A última etapa na dança do token 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 da Autenticação do OAuth para aplicativos da Web.

Veja alguns exemplos que usam cada uma das bibliotecas de cliente:

Observação: se você estiver usando HMAC-SHA1, salve a chave secreta do token de acesso com o valor do token no banco de dados. Caso contrário, não será possível reconstruir corretamente os parâmetros 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 assinará as solicitações e incluirá o cabeçalho de autorização correto para você. Normalmente, você recupera o token do usuário em um cookie ou banco de dados. Estes exemplos demonstram como reconstruir os parâmetros OAuth e fazer uma chamada à 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 de RSA-SHA1 é que você não precisa definir o secret do token de acesso, e a construção do objeto do signatário é 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

Esse snippet pressupõe que você já buscou um token de acesso (usando HMAC-SHA1) e está chamando essa chave/secret de token para uso posterior.

Se você estiver usando as classes mais recentes da v2.0 ou posterior com base no 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 com base 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 de RSA-SHA1 é que você não precisa definir o secret do token de acesso, e a construção do objeto do signatário é diferente:

RSA-SHA1 is not supported yet.

Recursos e amostras adicionais do OAuth de três etapas

Exemplos de OAuth no blog de dicas da API Google Data
Artigo: Como usar o OAuth com as APIs de dados do Google
Biblioteca de cliente Python exemplo
Biblioteca de cliente Python Exemplo do Google App Engine
Biblioteca de cliente Java exemplo
Biblioteca de cliente Java exemplo do Google App Engine
Biblioteca de cliente PHP Zend amostra
Documentação de Autenticação do 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. Dois grupos de chaves podem usar o OAuth de duas etapas:

Administradores de domínios do G Suite: os administradores podem criar scripts e apps personalizados que gerenciam os dados dos usuários do domínio nas APIs de dados do Google. Para saber mais sobre como gerenciar a chave e o secret associados ao seu domínio do G Suite e conceder controle de acesso global, consulte Como gerenciar a chave e o secret do OAuth.

Fornecedores de software de terceiros:os fornecedores podem oferecer aplicativos que usam o OAuth de duas etapas para fazer a integração com o G Suite. O acesso aos aplicativos de terceiros pode ser concedido na página "Gerenciar cliente" da API ou na instalação usando o G Suite Marketplace.

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

Nas amostras de biblioteca de cliente a seguir, demonstramos como configurar seu cliente para usar o OAuth de duas etapas usando 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 mais recentes da v2.0 ou posterior com base no 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 com base 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);
}

Recursos e amostras adicionais do OAuth de duas etapas

Exemplos de OAuth de duas etapas no blog de dicas da API Google Data
Biblioteca de cliente Java Exemplo de OAuth de duas etapas
Biblioteca de cliente Python TwoLeggedOAuthExample (para classes client.py) ou 2_leg_oauth sample (para classes service.py)
Biblioteca de cliente .NET Exemplo de OAuth de duas etapas
Documentação do OAuth de duas etapas

Gerar uma chave privada de assinatura própria e um certificado público

A chave privada é usada para gerar uma assinatura, que precisa ser incluída em cada solicitação. A chave pública incorporada ao certificado é usada pelo Google para verificar a assinatura. A chave pública precisa ser uma Chave RSA de 1.024 bits codificada em um certificado X.509 no formato PEM. O certificado 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 de dados do Google. Você pode usar os mesmos utilitários para gerar chaves para qualquer finalidade.

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

Como 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 senha para protegê-la. No entanto, considere a possibilidade de 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 contém o certificado no formato PEM, que pode ser enviado ao Google durante o registro.

Como gerar chaves para o cliente .NET

O framework .NET não entende chaves ou certificados armazenados no formato PEM. Portanto, é necessário realizar uma etapa adicional depois que você tiver criado 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 com base na chave privada e no 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 a partir do arquivo .pem gerado:

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

Se preferir, use o armazenamento de chaves 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

Aviso: "changeme" não é uma senha forte. 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