Integrar las APIs de login de Facebook, Yahoo y Windows Live

La filosofía del single sign-on ha terminado imponiéndose por pura lógica de saturamiento 2.0, con los grandes jugadores vendiendo sus nuevas propuestas (OpenID lo intentó y no lo consiguió…) y los usuarios cansados de procesos de registro y contraseñas varias. Darles a éstos la oportunidad de usar sus credenciales de alguno de los servicios top para utilizar tu sitio debería ser ya a estas alturas planteado como una funcionalidad primaria de cualquier proyecto web.

Lo que viene a continuación es una guía para implementar en tu web la funcionalidad de “login externo” usando las APIs de tres de los grandes: Facebook, Yahoo y Windows Live (Google y OpenID vendrán en otro post). El proceso es similar en todos los casos, y el objetivo es acabar teniendo para utilizar en nuestro código el id único externo (la variable $id_unico en los ejemplos) que nos sirva para identificar y validar al usuario en nuestro sistema local.

Facebook

La integración más sencilla de todas ¡5 líneas de código!

La documentación para desarrolladores de Facebook es de las mejores, con muchos ejemplos prácticos y una comunidad muy activa. Vamos a hacer la implementación más sencilla, sin meternos en Facebook Connect, que será chicha para otro post. Los pasos serían los siguientes:

1. Logueado en tu cuenta de Facebook debes añadirte la aplicación para desarrolladores.
2. Creamos una nueva aplicación, y rellenamos lo básico para que funcione (el resto es para configuraciones más avanzadas)

   

3. Nos bajamos la librería cliente de PHP.
4. ¡Y a picar!

Resumiendo, tenemos una api key, otra key privada, hemos especificado una URL propia de retorno de Facebook, y tenemos su clase de PHP (nos sobraría con los ficheros facebook.php y facebookapi_php5_restlib.php). Pues el script para loguearse con Facebook sería tan sencillo como esto:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

<?php
 
	// cargamos la clase que nos proporcionan
	require_once('apis_externas/facebook/class_facebook.php');
 
	// datos de la aplicación que se nos facilitan cuando la registramos en Facebook 
	$appapikey = '000000000000';
	$appsecret = '111111111111';
 
	// inicializamos el objeto de la clase
	$facebook = new Facebook($appapikey,$appsecret);
 
	// si el usuario no está logueado en Facebook le redirigirá allí
	$id_unico = $facebook->require_login();
 
	if(empty($id_unico))
	{
		// si a estas alturas no tenemos el id único algo ha salido mal
		$error_api = true;
	}
 
?>

Hay varias formas de hacer esto en Facebook, y no digo que esta sea la más correcta, pero seguro que la más sencilla. La importante es la línea 14, en la que si el usuario está logueado nos devolverá su id único, y sino le enviará a la página de login de Facebook.

Yahoo

Otra API con integración no traumática gracias a la tecnología BBAuth de Yahoo. Aquí también se pueden elegir varias implementaciones (OAuth, OpenID), pero de nuevo vamos a optar por la más sencilla y rápida de desarrollar. Los pasos son los siguientes:

1. Vamos a la página de alta de aplicaciones (se necesita usuario de Yahoo).
2. Creamos una nueva Browser-Based Authentication Protected Application

   

3. Nos pedirán confirmar el dominio subiendo un fichero determinado a nuestra web.
4. Nos bajamos la librería cliente de PHP.
5. ¡Y a picar!

Resumiendo de nuevo, tenemos la aplicación creada, apuntadas las dos keys que necesitamos y la clase para comunicarnos con Yahoo (usaremos el fichero ybrowserauth.class.php4 o ybrowserauth.class.php5 dependiendo de nuestra versión de PHP). El código final quedará así:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

<?php
 
	// datos de la aplicación que se nos facilitan cuando la registramos en Yahoo
	define('APPID','000000000000');
	define('SECRET','111111111111');	
 
	// cargamos la clase que nos proporcionan (en este caso tenemos PHP 5 en el servidor)
	require_once('apis_externas/yahoo/ybrowserauth.class.php5');
 
	// inicializamos el objeto de la clase
	$authObj = new YBBauthREST(APPID,SECRET);
 
	if(empty($_GET['token'])) 
	{
		// si no tenemos token mandamos a la página de login
		$url = $authObj->getAuthURL('',true);
		header('Location: '.$url);
		exit;
	}
 
	if($authObj->validate_sig()) 
	{
		// si validamos el token ya podemos sacar el id único
		$id_unico = $authObj->userhash;
	}
	else
	{
		// el token recibido no es correcto
		$error_api = true;
	}
 
?>

Es muy importante recordar que esta API es especial en el sentido que el id que se recibe finalmente es un hash del id único real del usuario en Yahoo y el id de la aplicación, es decir, si el mismo usuario de loguea con otra aplicación recibiremos un hash distinto, por lo que tenemos que tener en cuenta qué significa exactamente este id único que recibimos de la API.

Windows Live

Haciendo honor a su fama, y con mucha diferencia, la API de Windows Live es la más complicada de implementar, tanto por su horrenda documentación (lo de msdn es terminal…) como por el engorro general que supone lidiar con sus múltiples archivos y su extraño flujo de información.

Los pasos iniciales son similares a las anteriores APIs, la diversión viene después…

1. Vamos a la página de alta de aplicaciones (se necesita usuario de Windows Live).
2. Creamos un proyecto de Live Services: Existing APIs

   

   Es en este formulario cuando nos enfrentamos al primer problema absurdo, y es que el campo Return URL permite un máximo de 50 caracteres wtf?? cualquier ruta que no vaya a la raíz va a tener más de 50 letras! la única solución es tener una herramienta tipo firebug para poder editar online el HTML y cambiar el atributo maxlength del campo para poder enviar una URL en condiciones (lo que confirma lo absurdo de la limitación es que la página no te comprueba si has escrito más de esos 50 caracteres, se envía sin problemas…)
   Y atención también que la URL de retorno no es la misma que el resto de las APIs, es a un script que nos bajaremos luego con el SDK.

3. Nos bajamos el Web Authentication SDK para el lenguaje que vayamos a utilizar.
4. ¡Y a picar!

De nuevo tenemos una api key, otra key privada, hemos especificado una URL de retorno nueva, y tenemos su SDK con varios archivos. Lo primero es poner las keys en el fichero Application-Key.xml (debe ser innaccesible desde internet, bien limitándolo con un htaccess o colocándolo fuera del document root):

1
2
3
4
5

<windowslivelogin>
	<appid>000000000000</appid>
	<secret>111111111111</secret>
	<securityalgorithm>wsignin1.0</securityalgorithm>
</windowslivelogin>

Ahora en el directorio sample tenemos una implementación de ejemplo a la que podemos quitarle bastante paja. Lo primero es editar el fichero settings.php:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

<?php
 
	// por si las cosas no salen y se necesita consultar logs de errores 
	$DEBUG = false;
 
	// path completo al XML de configuración de la aplicación
	$KEYFILE = '/home/usuario/Application-Key.xml';
 
	// nombre de la cookie que almacena el token de usuario que manda la API
	$COOKIE = 'webauthtoken';
 
	// URL a la que tiene que redirigir cuando todo termine
	$INDEX = '/login_externo.php';
 
	// páginas a las que tiene que llevar cuanto se haga login o logout
	$LOGIN = $INDEX;
	$LOGOUT = $INDEX;
 
	// la URL de la API ¡no tocar!
	$CONTROLURL = 'http://login.live.com/controls/WebAuth.htm';
 
?>

En el fichero webauth-handler.php (recordar que es éste el que hemos puesto como URL de retorno al crear la aplicación) tenemos que poner la rutas correcta al fichero de configuración y a la librería de la API (el fichero windowslivelogin.php en el directorio lib):

1
2
3
4
5
6
7
8
9

<?php
 
	require('/home/usuario/dominio/windows_live/settings.php');
 
	require('/home/usuario/dominio/windows_live/lib/windowslivelogin.php');
 
	....
 
?>

Y finalmente el código que implementa la autenticación con Windows Live:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

<?php
 
	// el fichero de configuración de la API
	require('/home/usuario/dominio/windows_live/settings.php');
 
	// la librería del SDK
	require('/home/usuario/dominio/windows_live/lib/windowslivelogin.php');
 
	// inicializamos las variables
	$wll = WindowsLiveLogin::initFromXml($KEYFILE);
	$wll->setDebug($DEBUG);
	$APPID = $wll->getAppId();
	$userid = null;
 
	// comprobamos si el token de usuario está en la cookie
	$token = @$_COOKIE[$COOKIE];
	if(!empty($token))
	{
		$user = $wll->processToken($token);
		// tenemos token, intentamos sacar de él el id único del usuario
		if(!empty($user))
		{
			$userid = $user->getId();
		}
	}
 
	if(!empty($userid))
	{
		// guardamos el id único
		$id_unico = $userid;
	}
	else
	{
		// si no tenemos token, redirigimos al usuario a la página de login de Windows Live
		header('Location: http://login.live.com/wlogin.srf?appid=0000000040009631&alg=wsignin1.0');
		exit;
	}
}
 
?>

Quedaría, como en el resto de APIs, hacer una gestión eficiente de los errores que se pueden dar, aunque eso ya son detalles de implementación de cada aplicación.

Tampoco comento nada sobre los módulos de PHP que es necesario tener activados en el servidor para hacer funcionar las APIs. En principio los únicos que considero pudieran salirse de una configuración básica son curl y mhash. Curl se utiliza en la librería de Yahoo y es complicado buscarle una alternativa. Mhash se utiliza en la de Windows Live, y en este caso, siendo una extensión mucho menos común, se puede puentear su uso parcheando el fichero windowslivelogin.php, en concreto la línea:

1515

$key = mhash(MHASH_SHA256, $key);

Cambiándola para utilizar funciones del core de PHP5 que también realizan el hash binario SHA256:

1515

$key = pack("H*", hash('sha256', $key));