OAuth en las bibliotecas cliente del protocolo de datos de Google

Advertencia: Esta página trata sobre las API anteriores de Google, las API de datos de Google, y solo es relevante para las API que aparecen en el directorio de las API de datos de Google, muchas de las cuales se reemplazaron con API más nuevas. Para obtener información sobre una API nueva específica, consulta la documentación de la API nueva. Para obtener información sobre cómo autorizar solicitudes con una API más reciente, consulta Autenticación y autorización de cuentas de Google.

En este documento, se describe cómo usar las bibliotecas cliente de la API de datos de Google a fin de conectarse a la autenticación OAuth para aplicaciones web de Google.

La interfaz de OAuth permite que una aplicación basada en la Web acceda a un servicio de Google en nombre de un usuario. Para mantener un alto nivel de seguridad, OAuth permite que la aplicación obtenga un token de acceso sin siquiera administrar la información de acceso de la cuenta del usuario.

Las bibliotecas cliente de la API de datos de Google proporcionan métodos para ayudarte a utilizar OAuth en tu aplicación web. Específicamente, existen métodos para construir la adquisición de un token de solicitud, autorizar el token de solicitud e intercambiar el token de solicitud autorizado por un token de acceso. Las bibliotecas también controlan los algoritmos de firma necesarios cuando realizan solicitudes a un servicio de datos de Google.

Público

Este documento está destinado a programadores que desean que sus aplicaciones basadas en la Web accedan a los servicios de Google en nombre de los usuarios, mediante las bibliotecas cliente de las API de datos de Google.

En este documento, se supone que estás familiarizado con la interfaz de OAuth y con el proceso general para incorporar OAuth a tu aplicación web. Para obtener una descripción completa del protocolo de OAuth, consulta Autenticación de OAuth para aplicaciones web o la especificación oficial en oauth.net.

Cómo usar OAuth de tres segmentos y las API de datos de Google sin las bibliotecas cliente

Si deseas que tu aplicación web interactúe con un servicio de datos de Google utilizando OAuth como método de autorización, todo lo que necesitas saber está en Autenticación de OAuth para aplicaciones web. Si no lo desea, no es necesario usar las bibliotecas cliente de las API de datos de Google.

A continuación, se describe el modo en que tu aplicación puede autenticar a un usuario con OAuth:

  1. Tu aplicación realiza una solicitud firmada para recuperar un token de solicitud de OAuth inicial desde el extremo OAuthRequestToken.
  2. Tu aplicación redirecciona al usuario a la URL OAuthAuthorizeToken apropiada para autorizar el token de solicitud.
  3. Cuando otorgas acceso, se redirecciona al usuario de nuevo a tu aplicación (la URL oauth_callback).
  4. Tu aplicación envía una solicitud firmada para actualizar el token de solicitud autorizado a un token de acceso mediante el extremo OAuthGetAccessToken.

Las bibliotecas cliente de las API de datos de Google simplifican este proceso de autorización, ya que manejan varios detalles por ti. En este documento, se explica cómo hacerlo.

Registra tu aplicación web

OAuth requiere que todas las llamadas a la API se firmen de manera digital. Google admite los métodos de firma HMAC-SHA1 y RSA-SHA1. Para firmar las solicitudes, tu aplicación primero debe registrarse en Google. Una vez que te hayas registrado, Google te proporcionará una clave de consumidor (y un secreto para usar con HMAC-SHA1) y un lugar para subir un certificado público.

1. Cómo registrar su dominio

Sigue los pasos que se describen en Registro para aplicaciones basadas en la Web.

2. Crea un par de claves privadas o certificados públicos (opcional)

Si eliges usar RSA-SHA1 como oauth_signature_method, deberás crear una clave privada RSA y un par de certificados públicos autofirmados. Consulta Genera una clave privada autofirmado y un certificado público (a continuación) para obtener ejemplos sobre cómo hacerlo.

Cómo trabajar con OAuth de 3 segmentos y las API de datos de Google: ejemplos de biblioteca cliente

En las siguientes secciones, se muestran ejemplos de cómo usar los métodos de la biblioteca cliente de las API de datos de Google para seguir los pasos descritos en la sección "Trabaja con OAuth" de la documentación de OAuth. En todos los ejemplos de este documento, se supone que el dominio de host de tu aplicación es example.com.

Determina el alcance de tu acceso a los datos

Cada servicio de Google define un valor scope que determina el acceso de un token a los datos del usuario. Los valores de alcance disponibles se enumeran en las Preguntas frecuentes sobre datos de Google. Por ejemplo, para usar la API de lista de documentos, establece scope en https://docs.google.com/feeds/, como se muestra en las Preguntas frecuentes.

Nota: Establezca el valor scope en la URL más estrecha que permita el acceso que necesita. Esto reduce las posibilidades de obtener y filtrar accidentalmente los datos personales. Por ejemplo, si deseas acceder al feed privado de lista de documentos del usuario actual, usa el alcance https://docs.google.com/feeds/default/private/full en lugar de un alcance más amplio, como https://docs.google.com/feeds/, que proporciona acceso a todos los feeds de la lista de documentos.

Tokens de alcance múltiple

Para crear tokens que accedan a varias API de datos de Google, separa cada alcance con un carácter de espacio. En el siguiente ejemplo, se crea un token con acceso a los documentos de Google y a los datos de Calendario de Google de los usuarios.

scope=https://www.google.com/calendar/feeds/ https://docs.google.com/feeds/
Codificación de URL

Los caracteres que no son ASCII y que aparecen en las URL, incluidos los dos puntos, las barras diagonales y el espacio, deben estar codificados como URL para que se puedan transmitir mediante HTTP. Las bibliotecas cliente de la API de datos de Google codifican automáticamente los parámetros de URL, de modo que puedes simplemente usar strings que no estén codificadas en URL cuando asignes valores a los parámetros. Por ejemplo, puedes realizar la siguiente asignación en tu código:

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

Cuando llamas a la biblioteca cliente, el parámetro scope se codifica automáticamente en formato URL con el siguiente valor:
https%3a%2f%2fwww.google.com%2fcalendar%2ffeeds%2f+https%3a%2f%2fdocs.google.com%2ffeeds%2f

Recupera un token de solicitud

Java

Para HMAC-SHA1, necesitas alguna manera de conservar el secreto del token (que se obtuvo en la respuesta) a fin de crear un objeto de token de OAuth que regrese de la página de aprobación. Para ello, establece una variable de sesión o una 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);

Con RSA-SHA1, no se usa oauth_token_secret, por lo que no es necesario conservar el secreto del 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

Usa HMAC-SHA1 como el método de firma:

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

Usa RSA-SHA1 como el método de firma:

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

Usa HMAC-SHA1 como el método de firma:

Si usas las clases más recientes de la v2.0 basadas en GDClient, usa lo siguiente:

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

Usa RSA-SHA1 como el método de firma:

...

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, si usas las clases anteriores de v1.0 basadas en GDataService, las llamadas son algo 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)

Usa RSA-SHA1 como el método de firma:

...

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

Usa HMAC-SHA1 como el método de firma:

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

Usa RSA-SHA1 como el método de firma:

RSA-SHA1 is not supported yet.

Autoriza un token de solicitud

Para autorizar un token de solicitud, tu aplicación debe redireccionar al usuario a la URL OAuthAuthorizeToken, la cual le solicita que acceda a su cuenta de Google. Si deseas obtener más información sobre la URL OAuthAuthorizeToken, consulta la autenticación OAuth para aplicaciones web completa.

A fin de construir la URL OAuthAuthorizeToken en tu aplicación, usa lo siguiente para cada biblioteca cliente. Ten en cuenta que estas muestras se basan en los ejemplos anteriores.

Después de construir la URL de la página de aprobación, tu aplicación puede usarla de varias maneras para enviar al usuario al controlador OAuthAuthorizeToken. El enfoque más común es redireccionar al usuario o mostrar un vínculo a esa 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, puedes redireccionar a la URL de aprobación:

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

Python

Si usas las clases más recientes de la v2.0 basadas en GDClient, usa lo siguiente:

# 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 usas las clases anteriores de la versión 1.0 basadas en GDataService, el proceso es un poco 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);

Extrae el token de la URL de devolución de llamada

Cuando Google redirecciona a tu aplicación, el oauth_token se agrega a la URL "oauth_callback_url" como parámetro de consulta. Tu aplicación debe extraer el valor del token de su parámetro de consulta de URL y restablecer los parámetros de OAuth.

Las bibliotecas cliente proporcionan métodos convenientes para extraer la oauth_token. Estas muestras se basan en los ejemplos anteriores.

Java

Si decidiste conservar el secreto del token en la URL de devolución de llamada (cuando se usa HMAC-SHA1), haz lo siguiente:

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

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

La única diferencia con RSA-SHA1 es el método de firma:

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

Este paso no es necesario cuando se usa la biblioteca PHP.

Python

Si usas las clases más recientes de la v2.0 basadas en GDClient, usa lo siguiente:

# 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 usas las clases anteriores v1.0 basadas en GDataService, usa lo siguiente:

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'

El proceso es similar para RSA-SHA1, pero sin el secreto de 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

Si decidiste conservar el secreto del token en la URL de devolución de llamada:

OAuthUtil.UpdateOAuthParametersFromCallback(url, parameters);

Actualiza a un token de acceso

El último paso en la danza del token OAuth es actualizar el token de solicitud autorizado a un token de acceso de larga duración mediante la URL OAuthGetAccessToken, como se describe en la documentación completa de Autenticación OAuth para aplicaciones web.

A continuación, se incluyen algunos ejemplos que usan cada una de las bibliotecas cliente:

Java

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

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

PHP

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

Python

Si usas las clases más recientes de la v2.0 basadas en GDClient, usa lo siguiente:

# 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 usas las clases anteriores v1.0 basadas en GDataService, usa lo siguiente:

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

Si usas gdata.gauth.AeSave() en App Engine, se almacenarán el token y el secreto del token en el usuario que accedió.

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

Nota: Si usas HMAC-SHA1, asegúrate de guardar el secreto de token del token de acceso junto con el valor del token en tu base de datos; de lo contrario, no podrás reconstruir correctamente los parámetros de OAuth para su uso posterior.

Usa un token de acceso

Después de obtener un token de acceso, usa las llamadas estándar de la biblioteca cliente de las API de datos de Google para interactuar con el servicio. La biblioteca se encargará de firmar las solicitudes y de incluir el encabezado de autorización correcto. Por lo general, recuperarás el token del usuario desde una cookie o base de datos. En estos ejemplos, se muestra cómo reconstruir los parámetros del OAuth o realizar una llamada a la biblioteca cliente.

Java

Si usas 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 diferencia con RSA-SHA1 es que no necesitas establecer el secreto del token de acceso y la construcción del objeto firmante es 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

En este fragmento, se supone que ya obtuviste un token de acceso (mediante HMAC-SHA1) y que recuerdas esa clave o secreto del token para su uso posterior.

Si usas las clases más recientes de la v2.0 basadas en GDClient, usa lo siguiente:

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 usas las clases anteriores v1.0 basadas en GDataService, usa lo siguiente:

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 usas 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 diferencia con RSA-SHA1 es que no necesitas establecer el secreto del token de acceso y la construcción del objeto firmante es diferente:

RSA-SHA1 is not supported yet.

Recursos y muestras adicionales de OAuth de 3 segmentos

Volver al principio

OAuth de 2 segmentos

OAuth de 2 segmentos permite que las aplicaciones de confianza accedan a los datos de Google de los usuarios sin su participación directa. Dos grupos de claves pueden usar OAuth de dos segmentos:

Administradores de dominio de G Suite: Los administradores pueden compilar secuencias de comandos y aplicaciones personalizadas que administren los datos del usuario de su dominio por medio de las API de datos de Google. Para obtener información sobre cómo administrar la clave y el secreto asociados con tu dominio de G Suite y cómo otorgar control de acceso global, consulta "Cómo administrar la clave y el secreto de OAuth".

Proveedores de software de terceros: Los proveedores pueden ofrecer aplicaciones que usan OAuth de dos segmentos para integrarse con G Suite. El acceso para las aplicaciones de terceros se puede otorgar en la página del cliente de administración de API o mediante la instalación desde G Suite Marketplace.

No se requiere un token de acceso según el flujo de autorización normal (también conocido como OAuth de 3 segmentos).

En los siguientes ejemplos de biblioteca cliente, se muestra cómo configurar tu cliente para usar OAuth de 2 segmentos con HMAC-SHA1.

Java

import com.google.gdata.client.docs.*;
import com.google.gdata.client.authn.oauth.*;

String CONSUMER_KEY = "example.com";
String CONSUMER_SECRET = "abc123doremi";

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

DocsService client = new DocsService("yourCompany-YourAppName-v1");
client.setOAuthCredentials(oauthParameters, new OAuthHmacSha1Signer());

// Retrieve user's list of Google Docs
String user = "any.user@anydomain.com";
URL feedUrl = new URL("https://docs.google.com/feeds/default/private/full" +
                      "?xoauth_requestor_id=" + user);

DocumentListFeed resultFeed = client.getFeed(feedUrl, DocumentListFeed.class);
for (DocumentListEntry entry : resultFeed.getEntries()) {
  System.out.println(entry.getTitle().getPlainText());
}

PHP

require_once 'Zend/Oauth/Consumer.php';
require_once 'Zend/Gdata/Docs.php';

$CONSUMER_KEY = 'example.com';
$CONSUMER_SECRET = 'abc123doremi';
$USER = 'any.user@anydomain.com';

$oauthOptions = array(
    'requestScheme' => Zend_Oauth::REQUEST_SCHEME_HEADER,
    'version' => '1.0',
    'signatureMethod' => 'HMAC-SHA1',
    'consumerKey' => $CONSUMER_KEY,
    'consumerSecret' => $CONSUMER_SECRET
);

$consumer = new Zend_Oauth_Consumer($oauthOptions);
$token = new Zend_Oauth_Token_Access();
$httpClient = $token->getHttpClient($oauthOptions);

$client = new Zend_Gdata_Docs($httpClient);

// Retrieve user's list of Google Docs
$feed = $client->getDocumentListFeed('https://docs.google.com/feeds/default/private/full?xoauth_requestor_id=' . urlencode($USER));
foreach ($feed->entries as $entry) {
  echo "$entry->title\n";
}

Python

Si usas las clases más recientes de la v2.0 basadas en GDClient, usa lo siguiente:

import gdata.gauth
import gdata.docs.client

CONSUMER_KEY = 'example.com'
CONSUMER_SECRET = 'abc123doremi'
requestor_id = 'any.user@anydomain.com'

client = gdata.docs.client.DocsClient(source='yourCompany-YourAppName-v1')
client.auth_token = gdata.gauth.TwoLeggedOAuthHmacToken(
    CONSUMER_KEY, CONSUMER_SECRET, requestor_id)

# Retrieve user's list of Google Docs
feed = client.GetDocList()
for entry in feed.entry:
  print entry.title.text

Si usas las clases anteriores v1.0 basadas en GDataService, usa lo siguiente:

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 y muestras de OAuth adicionales de 2 segmentos

Genera una clave privada autofirmada y un certificado público

La clave privada se usa para generar una firma, que debe incluirse en cada solicitud. Google utiliza la clave pública incorporada en el certificado para verificar la firma. La clave pública debe ser una clave RSA de 1,024 bits codificada en un certificado X.509 en formato PEM. El certificado debe enviarse a Google en el momento del registro.

En las siguientes secciones, se proporcionan ejemplos de cómo generar claves y certificados con dos herramientas en particular: la utilidad OpenSSL y la utilidad keytool de Java.

Estos ejemplos no son específicos para las API de datos de Google; puedes usar las mismas utilidades para generar claves con cualquier propósito.

En los ejemplos, se supone que su empresa se llama My_Company y se encuentra en Mountain View, California, EE.UU., con el nombre de dominio example.com.

Genera claves con OpenSSL

Para crear un par de claves RSA y el certificado correspondiente, puedes usar el siguiente 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

Advertencia: Incluir el parámetro -nodes crea una clave privada sin una contraseña para protegerla. Sin embargo, deberías considerar omitir este parámetro para mayor seguridad.

El parámetro -sha1 especifica que la clave se usará para generar firmas SHA1.

El parámetro -subj especifica la identidad de la aplicación que representa el certificado.

El parámetro -keyout especifica el archivo que contendrá las claves. Este archivo contiene información sensible y debe protegerse y no compartirse con nadie.

El parámetro -out especifica el archivo que contendrá el certificado en formato PEM (que se puede enviar a Google durante el registro).

Genera claves para el cliente .NET

El marco de trabajo .NET no comprende las claves ni los certificados almacenados en formato PEM. Por lo tanto, se debe realizar un paso adicional después de crear el archivo .pem:

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

Este paso genera un archivo PFX desde tu clave privada y certificado. Este archivo se puede importar a la biblioteca cliente de .NET para firmar de forma digital las solicitudes realizadas a las API de datos de Google.

Genera claves para el cliente de Java

El cliente Java acepta claves privadas en formato PKCS#8. Después de generar una clave o un certificado con las instrucciones anteriores, crea un archivo .pk8 a partir de tu archivo .pem generado:

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

Como alternativa, puedes usar el almacén de claves de Java y la utilidad de keytool para crear un par de claves RSA y el certificado correspondiente. Usa el siguiente comando:

# 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

Advertencia: "changeme" no es una contraseña segura, es solo un ejemplo.

El parámetro -dname especifica la identidad de la aplicación que representa el certificado. El parámetro -storepass especifica la contraseña para proteger el almacén de claves. El parámetro -keypass especifica la contraseña para proteger la clave privada.

Para escribir el certificado en un archivo que pueda usarse en la herramienta ManageDomains, use el siguiente comando:

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

Volver al principio