OAuth en las bibliotecas cliente de los protocolos de datos de Google

Advertencia: Esta página trata sobre las APIs anteriores de Google, las APIs de Google Data, y solo es pertinente para las APIs que se enumeran en el directorio de las APIs de Google Data, muchas de las cuales se reemplazaron por APIs más nuevas. Para obtener información sobre una API nueva específica, consulta su documentación. 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 las APIs de Google Data para conectarse a la autenticación de 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 tener que controlar la información de acceso a la cuenta del usuario.

Las bibliotecas cliente de las APIs de datos de Google proporcionan métodos para ayudarte a usar 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 y cambiar el token de solicitud autorizado por un token de acceso. Las bibliotecas también controlan los algoritmos de firma necesarios cuando se realizan solicitudes a un servicio de Google Data.

Público

Este documento está dirigido a los programadores que desean que sus aplicaciones basadas en la Web accedan a los servicios de Google en nombre de los usuarios, utilizando las bibliotecas cliente de las APIs de Google Data.

En este documento, se supone que conoces la interfaz de OAuth y el proceso general para incorporar OAuth en tu aplicación web. Para obtener una descripción completa del protocolo de OAuth, consulta OAuth Authentication for Web Applications o la especificación oficial en oauth.net.

Usa OAuth de 3 segmentos y las APIs de datos de Google sin las bibliotecas cliente

Si quieres que tu aplicación web interactúe con un servicio de datos de Google usando OAuth como método de autorización, encontrarás todo lo que necesitas saber en Autenticación de OAuth para aplicaciones web. No es necesario que uses las bibliotecas cliente de las APIs de Google Data si no quieres.

A continuación, se incluye un esquema de cómo tu aplicación podría autenticar a un usuario con OAuth:

1. Tu aplicación realiza una solicitud firmada para recuperar un token de solicitud de OAuth inicial del extremo OAuthRequestToken.
2. Tu aplicación redirecciona al usuario a la URL de OAuthAuthorizeToken correspondiente para autorizar el token de solicitud.
3. Una vez que se otorga el acceso, se redirecciona al usuario a tu aplicación (la URL de oauth_callback).
4. Tu aplicación envía una solicitud firmada para actualizar el token de solicitud autorizado a un token de acceso con el extremo OAuthGetAccessToken.

Las bibliotecas cliente de las APIs de Google Data simplifican este proceso de autorización, ya que controlan 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 estén firmadas digitalmente. Google admite los métodos de firma HMAC-SHA1 y RSA-SHA1. Para firmar solicitudes, primero tu aplicación debe registrarse en Google. Una vez que te registres, Google te proporcionará una clave del consumidor (y un secreto para usar con HMAC-SHA1) y un lugar para subir un certificado público.

1. Cómo registrar tu dominio

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

2. Crea un par de clave privada y certificado público (opcional)

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

Cómo trabajar con OAuth de 3 segmentos y las APIs de Google Data: ejemplos de bibliotecas cliente

En las siguientes secciones, se muestran ejemplos del uso de los métodos de la biblioteca cliente de las APIs de Google Data para seguir los pasos que se describen en la sección "Cómo trabajar con OAuth" de la documentación de OAuth. En todos los ejemplos de este documento, se supone que el dominio del host de tu aplicación es example.com.

Cómo determinar el alcance de tu acceso a los datos

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

Nota: Establece el valor de scope en la URL más específica que permita el acceso que necesitas. Esto reduce la posibilidad de obtener y filtrar datos personales de forma accidental. Por ejemplo, si quieres acceder al feed privado de la 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 con varios permisos

Para crear tokens que accedan a varias APIs 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 datos de Documentos de Google y Calendario de Google de un usuario.

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 URLs, incluidos los dos puntos, la barra y el espacio, deben estar codificados como URL para poder transmitirse a través de HTTP. Las bibliotecas cliente de las APIs de Google Data codifican automáticamente los parámetros como URL, por lo que puedes usar cadenas sin codificar como URL cuando asignas valores a los parámetros. Por ejemplo, puedes hacer 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 como URL con el siguiente valor:

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

Cómo recuperar un token de solicitud

Java

Para HMAC-SHA1, necesitas alguna forma de conservar el secreto del token (que se obtiene en la respuesta) para 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, el oauth_token_secret no se usa, 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

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

Usando RSA-SHA1 como 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

Usando HMAC-SHA1 como método de firma:

Si usas las clases más recientes de la versión 2.0 o posterior 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')

Usando RSA-SHA1 como 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 de la versión 1.0 más antigua basadas en GDataService, las llamadas son un poco 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 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

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

Usando RSA-SHA1 como 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 de OAuthAuthorizeToken, que le solicitará que acceda a su Cuenta de Google. Para obtener más información sobre la URL de OAuthAuthorizeToken, consulta la Autenticación de OAuth para aplicaciones web completa.

Para construir la URL de 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 simplemente 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 versión 2.0 o posterior 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 de la versión 1.0 más antigua 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);

Cómo extraer el token de la URL de devolución de llamada

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

Las bibliotecas cliente proporcionan métodos convenientes para extraer el oauth_token. Estos ejemplos se basan en los anteriores.

Java

Si elegiste conservar el secreto del token en la URL de devolución de llamada (cuando usas 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 de PHP.

Python

Si usas las clases más recientes de la versión 2.0 o posterior 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 v1.0 anteriores 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 del 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 elegiste conservar el secreto del token en la URL de devolución de llamada, haz lo siguiente:

OAuthUtil.UpdateOAuthParametersFromCallback(url, parameters);

Actualiza a un token de acceso

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

A continuación, se incluyen algunos ejemplos de cómo usar 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 versión 2.0 o posterior 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 v1.0 anteriores basadas en GDataService, usa lo siguiente:

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

Si usas gdata.gauth.AeSave() en App Engine, el token y el secreto del token se almacenarán para ti en el usuario actual 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 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.

Cómo usar un token de acceso

Después de obtener un token de acceso, usa las llamadas estándar de la biblioteca cliente de las APIs de Google Data para interactuar con el servicio. La biblioteca se encargará de firmar las solicitudes y de incluir el encabezado de autorización correcto por ti. Por lo general, recuperarás el token del usuario de una cookie o una base de datos. En estos ejemplos, se muestra cómo reconstruir los parámetros de OAuth y 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 configurar el secreto del token de acceso y la construcción del objeto de firma 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 recuperaste un token de acceso (con HMAC-SHA1) y que recuerdas la clave y el secreto de ese token para usarlos más adelante.

Si usas las clases más recientes de la versión 2.0 o posterior 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 v1.0 anteriores 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 configurar el secreto del token de acceso y la construcción del objeto de firma es diferente:

RSA-SHA1 is not supported yet.

Recursos y muestras adicionales de OAuth de 3 segmentos

• Ejemplos de OAuth en el blog de sugerencias de las APIs de datos de Google
• Artículo: Usa OAuth con las APIs de datos de Google
• Ejemplo de la biblioteca cliente de Python
• Muestra de Google App Engine de la biblioteca cliente de Python
• Muestra de la biblioteca cliente de Java
• Muestra de Google App Engine de la biblioteca cliente de Java
• Muestra de la biblioteca cliente de Zend PHP
• Documentación de OAuth Authentication for Web Applications
• Documentación de OAuth.net

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 clave pueden usar OAuth de dos tramos:

Administradores de dominios de G Suite: Los administradores pueden crear secuencias de comandos y aplicaciones personalizadas que administren los datos del usuario de su dominio a través de las APIs de Google Data. Para obtener información sobre cómo administrar la clave y el secreto asociados a tu dominio de G Suite, y otorgar control de acceso global, consulta "Administración de 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 a las aplicaciones de terceros se puede otorgar en la página Administrar cliente de API o instalando la aplicació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 bibliotecas 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 = "[e-mail]";
URL feedUrl = new URL("https://docs.google.com/feeds/default/private/full" +
                      "?xoauth_requestor_id=" + user);

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

PHP

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

$CONSUMER_KEY = 'example.com';
$CONSUMER_SECRET = 'abc123doremi';
$USER = '[e-mail]';

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

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

$client = new Zend_Gdata_Docs($httpClient);

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

Python

Si usas las clases más recientes de la versión 2.0 o posterior basadas en GDClient, usa lo siguiente:

import gdata.gauth
import gdata.docs.client

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

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

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

Si usas las clases v1.0 anteriores 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 = '[e-mail]'

client = gdata.docs.service.DocsService(source='yourCompany-YourAppName-v1')
client.SetOAuthInputParameters(SIG_METHOD, CONSUMER_KEY, consumer_secret=CONSUMER_SECRET,
                               two_legged_oauth=True, requestor_id=requestor_id)

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

# Change to another user on your domain
client.GetOAuthInputParameters().requestor_id = '[e-mail]'

.NET

using Google.GData.Client;
using Google.GData.Documents;

// Create an OAuth factory to use
GOAuthRequestFactory requestFactory = new GOAuthRequestFactory("writely", "yourCompany-YourAppName-v1");
requestFactory.ConsumerKey = "example.com";
requestFactory.ConsumerSecret = "abc123doremi";

String user = "[e-mail]";

DocumentsService client = new DocumentsService("yourCompany-YourAppName-v1");
client.RequestFactory = requestFactory;

// Retrieve user's list of Google Docs
DocumentsListQuery query = new DocumentsListQuery();
query.Uri = new OAuthUri("https://docs.google.com/feeds/default/private/full", user, requestFactory.ConsumerKey);

DocumentsFeed feed = client.Query(query);

foreach (DocumentEntry entry in feed.Entries)
{
  Console.WriteLine(entry.Title.Text);
}

Recursos y muestras adicionales de OAuth de 2 segmentos

• Ejemplos de OAuth de 2 segmentos en el blog de sugerencias de las APIs de datos de Google
• Muestra de OAuth de 2 segmentos de la biblioteca cliente de Java
• Biblioteca cliente de Python TwoLeggedOAuthExample (para las clases de client.py) o muestra de OAuth de 2 segmentos (para las clases de service.py)
• Biblioteca cliente de .NET: Ejemplo de OAuth de 2 segmentos
• Documentación de OAuth de 2 segmentos

Cómo generar una clave privada y un certificado público autofirmados

La clave privada se usa para generar una firma, que se debe incluir en cada solicitud. Google usa 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 se debe enviar a Google en el momento del registro.

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

Estos ejemplos no son específicos de las APIs de Google Data. Puedes usar las mismas utilidades para generar claves para cualquier propósito.

En los ejemplos, se supone que tu empresa se llama My_Company, se encuentra en Mountain View, California, EE.UU., y tiene 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: Si incluyes el parámetro -nodes, se creará una clave privada sin contraseña para protegerla. Sin embargo, debes 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 de .NET

El framework de .NET no comprende las claves ni los certificados almacenados en formato PEM. Por lo tanto, se necesita un paso adicional una vez que hayas creado el archivo .pem:

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

En este paso, se genera un archivo PFX a partir de tu clave privada y certificado. Este archivo se puede importar a la biblioteca cliente de .NET para firmar digitalmente las solicitudes realizadas a las APIs de Google Data.

Cómo generar claves para el cliente de Java

El cliente de 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 del archivo .pem que generaste:

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

Como alternativa, puedes usar el almacén de claves de Java y la utilidad 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 buena contraseña; este 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 se pueda usar en la herramienta ManageDomains, usa 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