Archivo

Entradas Etiquetadas ‘red’

Publicando en Facebook como página para mantener a nuestros fans

Lunes, 30 de Enero de 2012 Gaspar Fernández Sin comentarios

poesiabinaria

Si administras una página de Facebook, esto te interesa, ya que puedes gestionar las publicaciones de forma automática, por ejemplo, si tienes muchas cosas que publicar y quieres hacerlo de manera escalonada, para no hacerlo todo seguido y mantener alerta a tus seguidores.

Para poder poner en práctica todo esto, te recomiendo leer estos artículos anteriores:

Estudiando el tema

El problema de administrar páginas, es que tienes que estar identificado como estas, y además, hacerlo en modo offline. Por otra parte, las páginas tienen sus administradores y éstos son los usuarios que se pueden identificar en aplicaciones.
Facebook hace todo esto a través de palabras de acceso (access tokens), cuando un usuario se identifica en una aplicación se genera un token único para ese usuario y éste durará un tiempo, durante ese tiempo, la aplicación podrá realizar las acciones que el usuario le ha dado permiso para hacer.

En el caso de las páginas, debemos generar un access token que valga para la página en cuestión que queremos manejar. Ese access token debemos pasárselo a la llamada a la API para publicar.

Obteniendo los access tokens de las páginas que administro

Para ello hay que hacer la llamada a la API /me/accounts, con lo que obtendremos un listado completo de las páginas que administramos, ID de páginas (para poder realizar las publicaciones) y los access tokens necesarios para publicar en nombre de esas páginas.

Podemos modificar el programa que teníamos para identificarnos (index.php) de la siguiente manera (facebook_ext está para descarga en un post anterior):

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
<?php

$api_key = 'xxxxxxxxxxx';
$api_sec = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx';

require_once('facebook_ext.php');
// Definimos constantes
define(NEEDED_PERMISSIONS,  'publish_stream,offline_access,manage_pages');

// Definimos códigos de error
define(NOT_INSTALLED,      1);
define(NO_PERMISSIONS,     2);

$facebook = new FacebookExtended(array(  
                       'appId'  => $api_key,
                       'secret' => $api_sec,
                       'cookie' => true ,
                     ));

try
{
 
  $sesion = $facebook->getUser();
  if (!$sesion)
    throw new Exception('Aplicación no instalada', NOT_INSTALLED);

  echo "Estamos identificados en Facebook<br/>";
  echo "Usuario: ".$sesion."<br/>";

  $permissions = $facebook->askForPermissions(NEEDED_PERMISSIONS);
   
  if (!$permissions)
    throw new Exception('No tengo permisos suficientes', NO_PERMISSIONS);
 
  print_r($facebook->api('/me/accounts'));
}
catch (FacebookException $e)
{
  echo "Error de Facebook: ".$e->getCode().": ".$e->getMessage();
}
catch (Exception $e)
{
  switch ($e->getCode())
    {
    case NOT_INSTALLED:
      $facebook->loginUser();
      break;
    case NO_PERMISSIONS:
      $facebook->loginUser(NEEDED_PERMISSIONS);
      break;

    case MALFORMED_ARRAY:
      echo $e->getMessage();
      break;

    default:
      echo "Ocurrió un error no identificado";
    }
}
?>

Con este código, pediremos permiso para administrar páginas, para uso offline y para publicar mensajes en nombre del usuario. Cuando estemos identificados, nos devolverá un array con los nombres de las páginas, los ID y los access tokens. El array dentrá la siguiente forma:

Array
(
[data] => Array
(
[0] => Array
(
[name] => Nombre de página 1
[access_token] => xxxxxxx
[category] => Website
[id] => 123456789
)

[1] => Array
(
[name] => Nombre de página 2
[access_token] => xxxxxxx2
[category] => Website
[id] => 987654321
)
………………..
[n] => Array
(
[name] => Nombre de página N
[access_token] => xxxxxxxn
[category] => Website
[id] => 918273645
)
)
)

Se mostrarán todas las páginas que administramos. Ahora tendremos que anotar el ID de la página con la que queremos publicar y el access token para copiarlos en el código del programa encargado de publicar.

Publicando como si fuéramos una página de Facebook

Para hacer la publicación tenemos que hacer una llamada a /ID_de_página/feed especificando el access token con el que queremos publicar:

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
<?php

$api_key = 'xxxxxxxxxxx';
$api_sec = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx';

require_once('facebook_ext.php');

$facebook = new FacebookExtended(array(  
                       'appId'  => $api_key,
                       'secret' => $api_sec,
                       'cookie' => true ,
                     ));

try
{
  // ID de la página que queremos editar. La podemos ver en la URL de Facebook de la página
  $destino=189639191053576;
  $access_token='XXXxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx';
  $public='Probando mensajes automáticos con el modo offline';

  print_r( $facebook->api('/'.$destino.'/feed', 'post', array('access_token' => $access_token,
                                  'message' => $public)));  
} catch (Exception $e)
{
  echo "Ocurrió un error";
}
?>

Facil, ¿no? Si trabajamos un poco con todo esto podemos conseguir automatizar los mensajes que se van a publicar en Facebook desde las páginas que gestionamos.

Categories: General, PHP, facebook Tags: , , , , , , ,

Publicando mensajes en Facebook sin que el usuario esté ahora mismo en la web [ modo offline ]

Viernes, 27 de Enero de 2012 Gaspar Fernández Sin comentarios

enchufe

Una de las grandes utilidades que nos da Facebook por si creamos una aplicación de escritorio, o una aplicación web que publique posts de nuestro blog automáticamente en nuestro muro, son los mensajes Offline, con este modo, no es necesario que un usuario esté identificado realmente en Facebook, aunque, debemos tener cuidado a la hora de trabajar con la aplicación, los usuarios nos han dado permiso para publicar en su nombre contenidos que nosotros generamos, por lo que debemos evitar que se pueda acceder a la publicación de contenidos directamente. Es decir, lo que voy a mostrar ahora es un mero ejemplo de cómo se haría, aunque muestro un programa que es lo más inseguro del mundo, ya que, cualquiera que entre en la dirección web especificada podrá escribir en Facebook con nuestro ID de usuario.

Creando la aplicación y practicando la publicación

Para esto, hay dos posts anteriores que te recomiendo leer si no lo has hecho ya:

Creando dos interfaces

Por un lado necesitamos la interfaz que conecta con Facebook, tal y como la hemos hecho ya en el post anterior, desde aquí se pedirá permiso para poder publicar mensajes, y para poder acceder de forma offline. Este será nuestro index.php en los ejemplos (aunque podemos cambiarlo por cualquier página que destinemos a la identificación en Facebook).

Por otro lado, necesitamos el script que realmente va a publicar texto en Facebook, este script no debe identificarse en el sistema, sólo debe enviar la publicación (será en el ejemplo publica.php)

El código fuente completo podrás verlo y descargarlo al final del post.

Pidiendo permiso

Para escribir en Facebook con el modo offline, debemos pedir el permiso, concretamente el permiso offline_access. Con este permiso la palabra clave que nos da acceso con el usuario elegido no caducará (las claves normales, sin offline access, tienen una caducidad limitada, aunque funcionarán durante un tiempo (¿minutos?) aunque el usuario haya dejado de estar activo).

Para manejar los permisos de Facebook de una mejor forma, he extendido la clase Facebook con algunos métodos que nos ayudarán a la hora de pedir permisos:

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
<?php
  /**
   *************************************************************
   * @file facebook_ext.php
   * @brief Extensión de la clase Facebook que permite manejar
   *        algunas opciones de forma más intuitiva.
   *
   * @author Gaspar Fernández <blakeyed@totaki.com>
   * @version
   * @date 14 ene 2012
   * Historial de cambios:
   *
   *
   *
   *************************************************************/

require ('facebook.php');

class FacebookExtended extends Facebook
{
  private $permissions=false;

  function __construct($config)
  {
    parent::__construct($config);
  }

  function askForPermission($ext_perm, $uid=false)
  {
    if (!$uid)
      $uid=$this->getUser();

    if (!$this->permissions)
      $this->permissions=$this->api('/'.$uid.'/permissions');
   
    if ( (isset($this->permissions['data'])) && (isset($this->permissions['data'][0])) )
      return $this->permissions['data'][0][$ext_perm];
  }

  function askForPermissions($ext_perms, $uid=false)
  {
    $permArray = explode(",", $ext_perms);

    $permissionsOk=true;

    $nElems=count($permArray);
    for ($i=0; $i< $nElems; $i++)
      {
    $ext_perm=trim($permArray[$i]);
    if ($ext_perm!='')
      {
        /* Internal debug */
        /* echo $i.'-'.$this->askForPermission($ext_perm, $uid)."<br>"; */
        $permissionsOk= ($this->askForPermission($ext_perm, $uid) && $permissionsOk);
      }
      }
    return $permissionsOk;
  }

  function loginUser($permissions)
  {
    if ($permissions)
      $loginUrl=$this->getLoginUrl(array('scope'=>$permissions));
    else
      $loginUrl=$this->getLoginUrl();

    header('Location: '.$loginUrl);
    exit;
  }

};
?>

Esta clase, se encargará de preguntar por los permisos que necesitamos de forma automática (en realidad fue como se explicó en el post anterior, aunque cuando tenemos que preguntar por varios permisos nuestro código puede crecer bastante).

Ahora, para pedir permiso haremos lo sigueinte:

1
2
3
4
$permissions = $facebook->askForPermissions('publish_stream,offline_access');
   
  if (!$permissions)
    throw new Exception('No tengo permisos suficientes', NO_PERMISSIONS);

La excepción podemos crearla como queramos, yo he seguido la técnica del post anterior, que podréis observar mejor con el código completo, lo que está claro es que el código no debe continuar pasado este punto, y debemos pedir los permisos necesarios. Además, a la hora de pedir los permisos, con la clase que hemos visto anteriormente, podemos hacer lo siguiente:

1
$facebook->loginUser('publish_stream,offline_access');

Con lo que también nos ahorramos unas líneas de código.

También, para publicar en nombre de los usuarios debemos obtener un Access Token, es una palabra de acceso única que identifica al usuario de Facebook en nuestra aplicación y nos permite interactuar, para ver esta palabra debemos hacer:

1
echo $facebook->getAccessToken();

Publicando contenido

Para publicar contenido, ahora hemos creado el archivo publica.php que sólo publicará contenido en el muro, con este archivo tenemos que tener especial cuidado, ya que en este caso, cualquiera podrá publicar contenido nada más accediendo al archivo (Código fuente de publica.php):

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
<?php

$api_key = 'Rellenar con nuestra API key';
$api_sec = 'Rellenar con nuestra API secret';

require_once('facebook_ext.php');

$facebook = new FacebookExtended(array(  
                       'appId'  => $api_key,
                       'secret' => $api_sec,
                       'cookie' => true ,
                     ));

try
{
  $destino="gaspy";     // O el nombre de usuario que queramos usar
  $public='Probando mensajes automáticos con el modo offline';
  $access_token='palabra que vimos cuando nos autorizamos, muy laarga';

  print_r( $facebook->api('/'.$destino.'/feed', 'post', array('access_token' => $access_token, 'uid' => $destino, 'message' => $public)));  
} catch (Exception $e)
{
  echo "Ocurrió un error";
}
?>

Ahora, para publicar contenido, en la llamada a la API debemos especificar:

  • uid = UID con la que queremos publicar, es decir, el usuario en nombre de quién hablamos.
  • message = Mensaje que queremos publicar
  • access_token = Palabra de acceso

Es más, podemos publicar en el muro o la página de quien queramos con esta técnica, igual que hacíamos antes, pero en este caso, lo hacemos sin que tengamos que estar identificados como ese usuario.

Código fuente de index.php

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
<?php

$api_key = 'Rellenar con nuestra API key';
$api_sec = 'Rellenar con nuestra API secret';

require_once('facebook_ext.php');

// Definimos códigos de error
define(NOT_INSTALLED,      1);
define(NO_PERMISSIONS,     2);
define(MALFORMED_ARRAY,   90);

$facebook = new FacebookExtended(array(  
                       'appId'  => $api_key,
                       'secret' => $api_sec,
                       'cookie' => true ,
                     ));

try
{
 
  $sesion = $facebook->getUser();
  if (!$sesion)
    throw new Exception('Aplicación no instalada', NOT_INSTALLED);

  echo "Estamos identificados en Facebook<br/>";
  echo "Usuario: ".$sesion."<br/>";

  $permissions = $facebook->askForPermissions('publish_stream,offline_access');
   
  if (!$permissions)
    throw new Exception('No tengo permisos suficientes', NO_PERMISSIONS);
 
  echo "No tienes que hacer nada, cierra esta ventana.";
}
catch (FacebookException $e)
{
  echo "Error de Facebook: ".$e->getCode().": ".$e->getMessage();
}
catch (Exception $e)
{
  switch ($e->getCode())
    {
    case NOT_INSTALLED:
      $facebook->loginUser();
      break;
    case NO_PERMISSIONS:
      $facebook->loginUser('publish_stream,offline_access');
      break;

    case MALFORMED_ARRAY:
      echo $e->getMessage();
      break;

    default:
      echo "Ocurrió un error no identificado";
    }
}
?>

Para descargar el código fuente: modooffline.tar.bz2 (1.7Kb)
Hay que incluir la API de Facebook para que funcione y sustituir $api_key y $api_sec por nuestra API Key y API secret respectivamente.

Foto: Samuel M. Livingston (Flickr)

Categories: Descarga disponible, PHP, facebook Tags: , , , , , , , ,

Probando Google+, vídeos, imágenes y vida digital integradas

Viernes, 1 de Julio de 2011 Gaspar Fernández Sin comentarios

Aunque he tardado un poco en entrar, estoy curioseando un poco. Hace poco, Google presentaba el botón +1 con el que desarrollaría una potente herramienta social, al estilo del “Me Gusta” de Facebook (¿alguien se acuerda de cuando era “Mola”?)  integrada con el buscador, bien, aquello era sólo una de las muchas pinceladas que nos dieron para lo que se nos venía encima.

Lo primero, será tener un Google Profile bien configurado, puesto que será la base de toda la comunicación. Desde Google han intentado introducir mejoras y conceptos innovadores en lo que respecta a redes sociales, todo eso combinado con una interfaz simplista, limpia y fácil de manejar, aunque si analizamos un poco más a fondo las posibilidades que nos brinda, no parece tan fácil de hacer.

La principal herramienta que vemos son los círculos, en principio pueden parecerse a las listas de amigos de Facebook (hay que compararlo con algo), aunque por lo que he podido ver es obligatorio introducir a los amigos en círculos, por lo que desde un primer momento nos ayudan a configurar nuestra privacidad, y a no compartir todo con todos por defecto.

El sistema nos permite compartir fotos y vídeos de forma fácil y rápida, por cierto, el visor de vídeos, utiliza el reproductor de Youtube, y nos permite añadir comentarios a medida que vemos el vídeo. Además, desde nuestro perfil podemos ver las webs a las que hemos marcado con +1, así podemos tenerlo todo junto y podremos acceder a ellas.

A través de Sparks encontramos la integración con el buscador, feeds que se pueden generar y seguir, aunque aún tengo que curiosear un poco más esto. Y por si fuera poco, nos dejan descargar nuestra “vida digital” con google directamente desde la web, algo muy importante para ver lo que hemos hecho, los mensajes recibidos, las fotos, etc (Recordemos que Facebook añadió esta opción hace unos meses, la podemos encontrar en la Configuración de Cuenta).

¿ Google+ vs Facebook ? ¿Por qué enfrentar dos herramientas? Usémoslas, es cierto que de unos años hasta ahora, tenemos que dedicar unos minutos al día a gestionar nuestra vida digital, y cuantos más servicios tengamos, más tiempo tenemos que invertir para tener nuestro perfil en Internet actualizado y limpio, y además nosotros estar al día de lo que ocurre. Es una herramienta más, un tanto diferente de lo que estamos acostumbrados. No tiene publicidad aún, y tal vez la integren en un futuro al estilo Gmail, y tampoco permite aplicaciones, y personalmente creo que no debería permitirlas, ya que ésta es una red que quiere dar importancia nuestra privacidad y lo que compartimos con los demás, y en Facebook muchos de los problemas en este sentido vienen por las aplicaciones.

La potencia de Facebook está en las aplicaciones y en la cantidad de gente que ya está ahí.

La ventaja de Google+ es la integración con los servicios de Google (que no son pocos), simplicidad, limpieza y mayor sensación de que nuestros datos no será utilizados para nada malo, hay que probarlo

Categories: General Tags: , , , , , , ,

Intercambiar mensajes en red local [ solución rápida con netcat y kdialog ]

Sábado, 23 de Octubre de 2010 Gaspar Fernández Sin comentarios

A veces tenemos la necesidad de, en la propia red local intercambiar algún mensaje de texto, ya sea una dirección web o algo así. Muchas veces se opta por enviar un e-mail, aunque aquí traigo una propuesta interesante. No para uso diario, pero para uso puntual cuando no tenemos nada a mano, o para estudiar el método.

Actualmente usa netcat y KDE (para la petición de datos de forma gráfica).

Con netcat sólo bastaría. En un ordenador ponemos:

$ netcat -l -p 6517

Actuaría como servidor escuchando por el puerto 6517 (he usado este puerto, porque creo que no hay ningún servicio definido en este lugar), luego en otro ordenador podemos escribir:

$ netcat [IP/host del primer ordenador] 6517

Con lo que conectaríamos con el otro ordenador. Es una conexión no cifrada, con lo que en este punto no estamos hablando de seguridad, sólo de un “apaño”.

Pero bueno, aunque sea un apaño no tiene por qué ser demasiado feo, así que vamos a acompañarlo de unos diálogos (con kdialog) y a hacer unos scripts que nos permitan iniciar netcat de forma fácil (incluso vincularlo a una tecla de nuestro sistema).

[ enviamensaje ]

1
2
3
4
5
host=`kdialog --inputbox "A que host quieres enviar un mensaje"`
mensaje=`kdialog --inputbox "Escribe el mensaje"`

# Puerto 6517 sin asignar
echo "$mensaje" | netcat -c $host 6517

Desde este archivo preguntamos al usuario el host con el que quiere hablar, y luego se le pide introducir el mensaje, que se mandará por netcat ( -c vale para que la conexión se cierre cuando se termine de enviar el mensaje )

[ recibemensaje ]

1
2
3
4
5
6
7
8
9
10
while read input
do
        kdialog --textinputbox "Alguien te manda algo" "$input" 2>&1 1>/dev/null;
        if [[ "$?" != "0" ]]
        then
                break;
        fi
done

echo "FIN DEL PROGRAMA"

Con este script escribiremos en un diálogo con kdialog el texto recibido por el mensaje. netcat nos pasará por su salida estándar el contenido del mensaje, así que tendremos que leerlo con read

Si aceptamos la ventana dejaremos de esperar mensajes.

[ servidormensajes ]

1
2
3
4
5
6
7
8
9
while (( 1 ))
do
        netcat -l -p 6517 -e ./recibemensaje
        kdialog --yesno "Desconectar servidor?"
        if [[ "$?" == "0" ]]
        then
                break;
        fi
done

Desde aquí ponemos el socket en escucha ( -l = listen ) en el puerto 6517 y lo que recibamos se lo pasamos al script recibemensaje; una vez que esto termine nos preguntará si queremos cerrar el servidor o estamos esperando mensajes de alguien más.

Ahora sólo tenemos que vincular a alguna tecla los script servidormensajes y enviamensaje con lo que podremos comunicarnos con las personas de nuestra red local sin problema. El programa también funcionará por Internet, si tenemos los puertos necesarios abiertos y redireccionados en el router (si usamos router) o nuestro firewall no restringe las conexiones por el puerto 6517 (aunque podemos cambiarlo).

Categories: Bash, Comunicación Tags: , , , , , , , ,

Login a Facebook y acceso a aplicación automatizado

Miércoles, 11 de Agosto de 2010 Gaspar Fernández Sin comentarios

A medida que va creciendo Facebook, los desarrolladores van siendo más imaginativos a la hora de crear aplicaciones que trabajen sobre esta red. Actualmente existen clientes para Facebook que no necesitan que estemos dentro de la página, y lo que presento a continuación es un pequeño ejemplo de todo ello.

Este script es parte investigación / parte navegación y lectura de foros en los que no he encontrado la respuesta exacta a mis necesidades. El problema está en que, a pesar de la existencia de Facebook Connect, si queremos automatizar tareas en Facebook tenemos que estar identificados en el sistema y entonces es cuando podemos hacer la tarea en cuestión.

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
<?php

$face_cookie='/tmp/fcbk_cookie';
$useragent="Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.2.3) Gecko/20100423 Ubuntu/10.04 (lucid) Firefox/3.6.3";
$login_email='*************';
$login_pass='**************';

function curl_load_url($url, &$error, $postfields=false)
{
  global $useragent, $face_cookie;
  $cu = curl_init();
  curl_setopt($cu, CURLOPT_URL, $url);
  curl_setopt($cu, CURLOPT_HEADER, 0);
  curl_setopt($cu, CURLOPT_FOLLOWLOCATION, 1);
  curl_setopt($cu, CURLOPT_SSL_VERIFYPEER, false);
  curl_setopt($cu, CURLOPT_RETURNTRANSFER, 1);
  curl_setopt($cu, CURLOPT_USERAGENT, $useragent);
  curl_setopt($cu, CURLOPT_COOKIEJAR, $face_cookie);
  curl_setopt($cu, CURLOPT_COOKIEFILE, $face_cookie);
  if ($postfields)
    {
      curl_setopt($cu, CURLOPT_POSTFIELDS, $postfields);
      curl_setopt($cu, CURLOPT_POST, 1);
    }

  $cont=curl_exec($cu);
  $error=curl_errno($cu);

  curl_close($cu);

  return $cont;
}

function fb_login($email, $passwd)
{
  $error=false;
  curl_load_url('http://login.facebook.com/login.php', $error);

  $ch_test='&euro;,&acute;,€,´,水,Д,Є';
  $postfields='cuarset_test='.urlencode($ch_test).'&locale=es_ES&email='.urlencode($email).'&pass='.urlencode($passwd).'&pass_placeholder=&cuarset_test='.urlencode($ch_test);
  $cont=curl_load_url('https://login.facebook.com/login.php?login_attempt=1', $error, $postfields);

 /* Si hay un error de cURL lo decimos */
 if ($error)
   echo 'Error (cURL): '.$error."\n";

 /* Esta palabra *login_attempt* aparece en los intentos de login de Facebook */
 /* es raro que en la página principal salga. */
 /* Podemos también, verificar si está el enlace a editaccount.php para decir */
 /* que hemos sido identificados correctamente */
 if (strpos($cont, 'login_attempt')!==false)
/*  if (strpos($cont, 'editaccount.php')===false) */
   {
     echo 'Error (Facebook): E-mail o contraseña incorrecto';
     $err=1;
   }
 /* Si no hay errores nos daremos por identificados, aunque si el password es incorrecto */
 return (!$err);
}

if (fb_login($login_email,$login_pass)){
  $error=false;
  $cont = curl_load_url('http://apps.facebook.com/minutofilosofico/', $error);
  // Mostramos el contenido de la página
  echo $cont;
}
?>

¿Qué aplicaciones prácticas puede tener esto? Podemos hacer fácilmente un programa de escritorio para manejar Facebook, enviarnos por e-mail o un sms automáticamente si alguien que esperamos nos escribe, subir fotos de forma más rápida con un script en nuestro ordenador… o publicar un mensaje a la hora que hayamos especificado.

Como el ejemplo está en cURL será fácil portarlo a otro lenguaje con el que os sintáis más cómodos.

Categories: Comunicación, PHP, facebook Tags: , , , , , ,

Sobre los 100 millones de usuarios de Facebook ¿Robados? ¿Filtrados?

Domingo, 1 de Agosto de 2010 Gaspar Fernández Sin comentarios

Hace unos días, surgió la noticia de un hacker, Ron Bowes de Skull Security, quien con un par de scripts (ahora mismo la web no funciona) ha conseguido recopilar toda la información pública de más de 100 millones de perfiles de Facebook, es decir, lo que es visible para todos, los que no tenemos como amigos, además es un archivo 100% legal, ya que lo único que la información recopilada es la que los usuarios comparten con todos. Por si fuera poco está publicada en un torrent 100% accesible a cualquiera.

Paso a continuación una serie de enlaces donde ver la noticia: Alt1040, Blog de Manuel Pereira González, ABC, Thinq, y muchos más sitios.

Aunque en muchos titulares habla de que el archivo incluye números de teléfono y fechas de nacimiento, querría desmentir todo aquello, copio un fragmento del archivo README con el contenido del archivo:

facebook.rb The script used to generate these files (v1)
facebook.nse The script that will be used for the second pass (v2)
facebook-urls The full URLs to every profile
facebook-names-original All names, including duplicates
facebook-names-unique All names, no duplicates
facebook-names-withcount All names, no duplicates but with a count
facebook-firstnames-withcount All first names (with count)
facebook-lastnames-withcount All last names (with count)
facebook-f.last-withcount All first initial last name (with count)
facebook-first.l-withcount All first name last initial (with count)

Vemos que, como mucho, contiene el nombre y la URL, aunque por otra parte, he de decir que no sería demasiado difícil extraer los datos que figuren como públicos en estos perfiles, aunque todavía hay esperanza para aquellos que no han hecho sus datos privados.

Aunque por otra parte, yo que tengo el perfil abierto, con todos los datos públicos, no aparezco en el listado, por lo que es interesante buscarse. Para ello:

$ bzcat facebook-urls.txt.bz2 | grep [identificativo de tu URL de Facebook]

Donde el [identificativo de tu URL de Facebook] es lo que ponemos en la barra de direcciones para acceder a nuestro perfil: http://www.facebook.com/….

O también podemos buscar por nombre

$ bzcat facebook-names-unique.txt.bz2 | grep nombre

Así saldrán todos los que se llaman como tú.

Eso sí, leo en Alt1040 otra noticia, muchas empresas se están descargando el torrent, a pesar de sus políticas de protección de datos, anti-torrents, etc, y esperemos que en los próximos días no empiece a llegar spam por Facebook.

Categories: Interneteando, facebook Tags: , , , , , , , ,

Visita otras webs de la red