GECO's blog

Ya están disponibles los paquetes debian de geco. Todo el proyecto está compuesto por un total de cuatro paquetes independientes:

• gecod: Servidor GECO, es el que tiene la base de datos y el que alamacena la contraseñas. Combinandolo con cualquier cliente tienes un gestor de contraseñas completo.
• python-gecoc: Módulo python que proporciona las funcionalidades necesarias para crear un cliente geco o para interactuar con un servidor geco desde python (de este dependen los clientes gtk-geco y web-geco). También incluye el script terminal-geco
• gtk-geco: La interfaz de escritorio. Es la interfaz más completa y usable. Ofrece toda la funcionalidad.
• web-geco: Interfaz web. Con esta interfaz puedes ofrecer un servicio de acceso a contraseñas remoto

Para usarlo como un gestor de contraseñas de escritorio es necesario instalar gecod, python-gecoc y gtk-geco. El servidor se lanzará por defecto, por lo que el cliente de escritorio deberás conectarlo a https://localhost:4343 que es tu servidor gecod, te registras, guardas tu configuración y a disfrutar.

Trucos para gtk-geco

Si pulsas con el botón derecho sobre una contraseña se copia la cuenta al portapapeles no la contraseña.

Si haces doble click sobre el icono aparecerá un dialogo de busqueda, para un acceso más rápido.

Pulsando con el botón derecho sobe el icono aparecen más opciones.

Si te dice que no ha encontrado el fichero de configuración y ya existe, es posible que hayas puesto mal la contraseña, pulsa en olvidar y luego en preferencias, volverá a pedirte la contraseña.

Otras cosas

Por otra parte he añadido nuevas funcionalidades al cliente de escritorio. Por ejemplo ya se puede cambiar la contraseña maestra desde la preferencias. Además de poder realizar busquedas con autocompletado y también es posible copiar la cuenta en lugar de la contraseña al portapapeles.

Ah, y he cambiado el desarrollo del proyecto a la forja de sugus, así que si te interesa participar, te falla algo o tienes alguna sugerencia, puedes crear una petición nueva.

Esta semana, los días 7 y 8 de Mayo ha tenido lugar la fase final de Concurso Universitario de Software Libre. Esta final, como las dos anteriores ha tenido lugar en la Escuela Técnica Superior de Ingeniería Informática de la Universidad de Sevilla. Y como en anteriores ediciones ha consistido en dos días completos de ponencias y charlas, incluyendo entre estas las presentaciones de los seis proyectos finalistas y la entrega de premios.

Este año además de como colaborador he asistido como finalista con el proyecto GECO. Además este año se ha celebrado la fase final en el salón de actos mientras que en años anteriores se hizo en el salón de grados. El salón de actos es realmente grande y separa muchísimo a los ponentes del público, algo que intimida al ponente y por otra parte hace que los asistentes tengan más complicado participar con preguntas.

Como en todo evento de este tipo lo más importante es relacionarse con ponentes y otros participantes, compartir ideas e impresiones, poner cara a gente que sólo conoces a través de internet y hacer amigos.

Yo por mi parte he aprendido mucho de los demás participantes y ponentes, me gustaría haber hablado más, pero por diferentes motivos al final hemos hablado poco, pero bueno, ha estado bastante bien.

El año que viene no creo que pueda participar, porque comenzaré con los estudios de doctorado, que quedan fuera del ámbito del concurso, pero me tocará colaborar, medio organizar y espero poder "tutorar" o ser el mentor de algún estudiante que necesite mi ayuda o guía para participar. Tengo varios proyectos para el que no tenga nada en mente y seguro que saldrán muchos más.

Premios

Premio innovación: eOPSOA
Finalista innovación: Cool Imaging

Premio comunidad: AVBOT
Finalista comunidad: Digital Coach

Premio ocio: Tucan
Finalista ocio: Geco

Los premiados se llevan 2000 euros y una subscripción a Linux Magazine y los finalistas 1000 euros y una subscripción digital.

Quiero decir que para los participantes el concurso no acaba aquí, en septiembre comienza de nuevo y podréis participar incluso mejorando el mismo proyecto, si os pasa como a mí que ya acabáis y demás siempre podéis seguir ligados al concurso colaborando a la difusión, impulsando a nuevos alumnos universitario a participar e incluso colaborando con los proyectos, porque no olvidemos que esto es software libre y que toda colaboración es bienvenida.

Para la presentación de GECO en la Fase Final del Concurso Universitario de Software Libre he preparado un pequeño comic en el que creo que se muestra de una manera más clara y amena el porqué de GECO.

El 28 de abril se dió a conocer la lista de finalistas del tercer concurso universitario de software libre (CUSL3) y resulta que GECO ha salido seleccionado.

Esto es una gran noticia después de que en el concurso local de Sevilla también recibiera un premio, así que parece ser que el tiempo y esfuerzo dedicado a este proyecto está dando sus frutos.

GECO no nació como un proyecto para ganar el concurso, tan solo era una necesidad personal que quería implementar y para la cual aproveché el concurso como medio de motivación y una oportunidad para aprender un poco más. Marcandome unos plazos e implementando la parte funcional primero he conseguido un proyecto que podría considerarse casi cerrado, hoy en día se podría decir que está en la versión 0.99, tan sólo falta por añadir una pequeña funcionalidad a los clientes, pero que gecolib ya contempla.

Muchas gracias a todos los que han hecho posible este concurso y a todos los participantes. Una idea que no se intenta llevar a cabo es una idea menos. Así que ningún desarrollo es en vano.

Siempre es bueno colaborar en otros proyectos de software libre y más aún cuando el proyecto lo están haciendo compañeros de la asociación SUGUS.

Ya dejaron caer un par de veces Alex y Edulix que al proyecto meshias no le vendría mal un logo, así que una tarde me puse a ello y salió esto:

Ya que estabamos y puesto que este proyecto me pareció interesante estuve mirando un poco el código y también arreglé un pequeño bug por ahí.

Pienso seguir colaborando tanto en este proyecto como en otros que considere interesantes. Y esta es otra muestra más de que este "Concurso Universitario de Software Libre" no va de rivalidad ni de ganar premios, sino de llevar a cabo proyectos y entre todos aprender.

Y por supuesto no he abandonado todavía GECO, aún le quedan un par de detalles para considerarlo como proyecto acabado y espero dedicarle un par de tardes esta semana para que esté terminado para la fase final.

Cada vez que hago un desarrollo comienzo creando una carpeta y a partir de esa carpeta raíz del proyecto comienzo a generar todo lo necesario para que se pueda ejecutar. Hasta hace bien poco GECO estaba así y se podían ejecutar cada una de sus partes, tanto el servidor como el cliente de forma simple tan solo entrando en el directorio correspondiente y lanzando el script.

Pero cuando comienzas a utilizar un programa de manera más o menos habitual, no es cómodo el tener que entrar en el directorio correspondiente y lanzar el script, para un uso habitual es más conveniente el tener el programa instalado como uno más del sistema. Y esto es lo último que he realizado, un instalador sencillo que te deja todo donde "debe" estar para facilitar el uso.

Python ofrece una forma sencilla de hacer instaladores de módulos y programas, es el conocido módulo distutils. Normalmente los programas en python cuando te los descargas vienen con un fichero setup.py el cual hay que ejecutar para que se instale en el sistema, es una especie de make, pero para python.

¿Cómo crear un fichero setup.py?

El fichero setup.py no es más que un pequeño script en python en el cual tendremos que definir qué queremos que se instale, autor, descripción y otros datos.

Veamoslo con ejemplos:

# setup.py de gecoc
from distutils.core import setup
 
setup(name = 'gecoc',
      version = '1.0',
      description = 'geco client lib',
      author = 'Daniel Garcia Moreno',
      author_email = '<dani@danigm.net>',
      url = 'http://bzr.danigm.net/geco',
      license = 'GPLv3',
      scripts = ['terminal-geco'],
      packages = ['gecoc']
      )

$sudo python setup.py install

Con este script se puede instalar la librería gecolib que está en el paquete gecoc y el script terminal-geco. La mayoría de las opciones se entienden perfectamente, son datos opcionales que dan información sobre el programa. Las partes importantes en este ejemplo son las opciones scripts y packages. Scripts instala la lista de scripts en /usr/bin y packages instala un paquete python (directorio con __init__.py) en /usr/lib/pythonX.X/site-packages/.

El directorio destino de la instalación se puede cambiar y poner otro en lugar de /usr/, por ejemplo /usr/local/

$sudo python setup.py install --prefix=/usr/local/

# setup.py de gtk-geco
from distutils.core import setup
import os
 
datafiles = []
 
for i in os.listdir('glade'):
    datafiles.append(('share/gtk-geco/', ['glade/'+i]))
 
datafiles.append(('share/pixmaps', ['geco.png']))
datafiles.append(('share/applications', ['gtkgeco.desktop']))
 
setup(name = 'gtk-geco',
      version = '1.0',
      description = 'gtk client for geco',
      author = 'Daniel Garcia Moreno',
      author_email = '<dani@danigm.net>',
      url = 'http://bzr.danigm.net/geco',
      license = 'GPLv3',
      data_files = datafiles,
      scripts = ['gtk-geco'],
      py_modules = ['gtkgeco'],
      packages = ['gecoc']
      )

Este otro ejemplo es el instaldor de la aplicación de escritorio gtk-geco. En este caso además de instalar un script y el paquete gecoc se instala un módulo python, que es un simple fichero .py y una serie de datos, que se hace con data_files. Con datafiles se puede instalar cualquier tipo de archivo en cualquier ruta del sistema. Si la ruta es relativa se instala a partir de La ruta /usr (o la que se haya especificado), y si la ruta es absoluta se usa esa. La ruta define un directorio y la lista de ficheros siguiente serán los que se copien a dicha ruta.

Facilitando un poco más la instalación

Tengo el código dividido en dos carpetas dentro de src, gecod y gecoc y dentro de gecoc está gtk-geco y web-geco que son dos clientes diferentes. Para facilitar la instalación he creado un script en bash que se encarga de instalar el módulo que deseemos de manera sencilla:

#!/bin/bash
 
function install_help(){
		echo "Ayuda del instalador $(basename $0)"
                echo "   Con este instalador puedes instalar:"
                echo "     gecod"
                echo "     gecoc"
                echo "     gtk-geco"
                echo "     web-geco"
                echo ""
                echo " Usalo pasando como argumento el nombre de lo que quieras instalar"
                echo " por ejemplo:"
                echo "    sudo ./$(basename $0) gecod"
}
 
root=$PWD
 
if [ "$#" -eq 0 ]
then
    install_help
    exit 0
fi
 
while [ "$#" -gt 0 ]
do
	case $1 in
	-h | --help)
        install_help
		shift
		;;
	gecod)
        cd $root
        cd src/gecod/
        echo "instalando gecod"
        python setup.py install
		shift
		;;
	gecoc)
        cd $root
        cd src/gecoc/
        echo "instalando gecoc"
        python setup.py install
		shift
		;;
	gtk-geco)
        cd $root
        cd src/gecoc/gtk-geco
        echo "instalando gtk-geco"
        python setup.py install
		shift
		;;
	web-geco)
        cd $root
        cd src/gecoc/web-geco
        echo "instalando web-geco"
        python setup.py install
		shift
		;;
	*)  
        install_help
		shift
		;;
	esac
done

Y con este instalador instalar por ejemplo el cliente de escritorio es tan fácil como ejecutar:

$sudo ./install.sh gtk-geco

Hace ya algún tiempo que hice la interfaz gráfica de GECO y esto lo hice usando glade para generar un fichero xml que posteriormente se carga desde python y se trabaja con los controles. Así se consigue separar la capa de presentación de la lógica del programa y es muy simple cambiar casi cualquier aspecto gráfico sin tener que tocar código.

Para hacer aplicaciones de escritorio con gtk lo más simple es utilizar glade-3, en casi todas las distribuciones hay varios paquetes, glade o glade-2 y glade-3. En las versiones anteriores el editor glade presentaba varias ventanas dispersas, al estilo gimp, pero glade-3 presenta una interfaz unificada y mucho más intuitiva.

Es muy sencillo crear una interfaz con este programa, sólo tienes que ir pinchando en los controles que quieras añadir y se van dibujando sobre la marcha, luego cambias sus propiedades y le das el aspecto visual que prefieras.

La mayoría de los manuales de pygtk y glade indican que hay que hacer lo siguiente para cargar una interfaz creada con glade desde código python:

import gtk.glade
 
class Ventana:
    def __init__(self):
        self.gladefile = "window.glade"  
        self.glade = gtk.glade.XML(self.gladefile)
 
        #accediendo a los controles
        self.button = self.glade.get_widget('button1')
        self.button.connect('clicked', action)

¿Qué simple verdad? pues en principio no funciona, cuando lo intentas hacer no funciona, a no ser que en el glade le des a guardar como libglade. Esto es porque desde hace algún tiempo, y yo no me había enterado, se utiliza otro formato que es gtkbuilder. Para utilizar interfaces generadas con glade y guardadas como gtkbuilder (que es como debería ser) hay que hacerlo de la siguiente manera:

import gtk
 
class Ventana:
    def __init__(self):
        self.gladefile = "window.glade"  
        self.glade = gtk.Builder()
        self.glade.add_from_file(self.gladefile)
 
        #accediendo a los controles
        self.button = self.glade.get_object('button1')
        self.button.connect('clicked', action)

Como podrás observar no ha cambiado mucho la cosa, solo cambiar get_widget por get_object y poco más.

Una vez cargado un objeto ya se puede trabajar con él, modificándolo, obteniendo información de él, etc. Para conocer todos los métodos y señales disponibles lo mejor es mirar la documentación.

Más facilidades, connect_signals, antiguo autoconnect

Desde glade, además de poner los controles en su sitio y definir los nombres se pueden definir funciones asociadas a los diferentes eventos que el objeto en cuestión pueda recibir. Así podemos evitarnos el tener que enlazar todos los botones con sus correspondientes funciones con el método connect, como se puede ver en los ejemplos anteriores y se pueden enlazar todas las funciones con una serie de funciones o métodos definidos.

Supongamos que tenemos una interfaz con un par de botones y hemos enlazado la señal clicked de cada botón con dos funciones llamadas boton1 y boton2 respectivamente.

Para que estos botones hagan algo, tendríamos un código así:

import gtk
 
class Ventana:
    def __init__(self):
        self.builder = gtk.Builder()
        self.builder.add_from_file('test.glade')
        self.window = self.builder.get_object('window1')
        self.window.show_all()
 
        # Magia :P
        self.builder.connect_signals(self)
 
    def boton1(self, widget):
        print "boton1"
 
    def boton2(self, widget):
        print "boton2"
 
if __name__ == '__main__':
    v = Ventana()
    gtk.main()

Si al método connect_signals se le pasa una instancia, buscará el nombre de las funciones en sus métodos, sin embargo también puede recibir un diccionario, y en tal caso, buscará las funciones a enlazar en ese diccionario.

También es posible pasarle argumentos a las funciones, pasándole otro argumento al método connect_signals:

...
        self.builder.connect_signals(self, 'mas info')
...
    def boton1(self, widget, data):
...
    def boton2(self, widget, data):
...

Y con esto y un bizcocho, hacer interfaces gráficas con pygtk y glade es mucho más simple de lo que nunca pudieras imáginar :P

Este fin de semana me he puesto a hacer el cliente de escritorio, que ya hacía tiempo que quería meterle mano.

El sábado por la noche tras llegar de jugar a los bolos me senté en mi escritorio y estuve programando a oscuras hasta que el cliente de escritorio tomó forma y fué usable.

Basandome en otros desarrollos que ya tenía, como sweetgtk hice la interfáz lo más simple y usable posible. Es un icono de sistema y al pulsarlo sale una lista con todas nuestras contraseñas. En ese listado aparece el nombre de la contraseña, que es clickable, el tiempo de expiración que está representado por una bolita verde, amarilla o roja y dos botones, uno para editar y otro para borrar.

Si se pulsa sobre el nombre de una contraseña nos pedirá la contraseña maestra (si no la sabe ya) y cuando la introduzcamos se copiará la contraseña al portapapeles, lista para ser pegada. Además el icono se pondrá verde, que quiere decir que recuerda la contraseña. Al pasar diez minutos el icono volverá a estar rojo y si queremos copiar otra contraseña habrá que introducir la contraseña maestra de nuevo.

Al pulsar con el botón derecho sobre el icono aparece un menu desde el cual se puede cerrar el programa, configurar (aún no implementado) y añadir nuevas contraseñas.

La ventana de adición de contraseñas muestra un formulario donde se pueden generar las contraseñas de forma automática y además tiene un indicador de la fortaleza de una contraseña en concreto.

Aún está muy verde el cliente de escritorio, con las configuraciones en código y cosas sin implementar pero con un par de tardes más ya estará completo.

Durante esta semana he realizado un avance bastante grande, si bien quería haber comenzado con el desarrollo del cliente de escritorio, lo he pospuesto para dejar prácticamente listo el cliente web, con toda la funcionalidad que debiera tener.

Así pues esta semana he implementado la posibilidad de exportar todas las contraseñas para después importarlas en otro servidor o como copia de seguridad.

La exportación es un simple volcado de las contraseñas del usuario tal y como se almacenan en la base de datos. Las contraseñas están cifradas, por lo tanto el fichero en teoría es seguro. El formato elegido ha sido lo más simple posible, un fichero de texto en el cual por cada línea hay una contraseña y los campos están separados por barras verticales.

En este proceso he tenido algunos problemas con las codificaciones pero parece que lo he acabado solventando.

La importación funciona a modo de mezcla, comparando por fecha de actualización si una contraseña ya existe, y en tal caso prevalece la que tenga fecha de actualización posterior. En ningún momento se borran contraseñas durante la importación, eso lo dejaré para otro proceso similar que será una importación con preferencia.

Esta nueva funcionalidad la he implementado en los dos clientes que llevo por el momento, que son el cliente de terminal y el cliente web.

Cambios en el cliente web

Para dar soporte a esta funcionalidad he añadido una nueva página al cliente. Esta página es la de "Opciones". Además ya que he creado una nueva página he añadido la funcionalidad de cambiar la contraseña del usuario de GECO y la posibilidad de borrar la cuenta del servidor, que ya estaban implementadas en gecolib y en el cliente de terminal.

Además, dado que tenía que hacer que estas páginas sean accesibles he añadido un pequeño menú.

Por otra parte, había otro tema que tenía pendiente en el cliente web, y es que no controlaba los errores debidamente. Así que hoy he añadido una página de error para que cuando pase algo inesperado no salga un mensaje feo, sino una página más o menos bonita.

Aún así se puede ver que la página está muy bien, pero no muestra nada de información, así que cuando ocurra un error habrá que investigar el por qué desde el lado del servidor y no del cliente :P

Yo sigo a lo mio, aunque no lo parezca. He seguido desarrollando pequeñas cositas del cliente web de GECO. Lo ultimo que me quedaba por desarrollar desde la ultima entrada en el blog era la modificación de contraseñas. Pues bien, eso ya esta hecho, se pueden modificar contraseñas y además le he añadido la posibilidad de mostrar la descripción de esa contraseña.

Por lo tanto podría decir que el cliente web esta terminado, en fase beta. Lo único que le falta es el poder cambiar la contraseña de la cuenta en GECO, poder borrar la cuenta y poder hacer un cambio de contraseña maestra masivo.

Ahora que lo pienso una funcionalidad curiosa seria poner un botón de exportación, que te diera un tar.gz o un zip con todas las contraseñas, cifradas, para poder importarlas en otro servidor GECO o como copia de seguridad.

Pronto comenzare a desarrollar el cliente gtk, que no debe ser nada de complicado porque todo el trabajo esta hecho en gecolib.

Animo a cualquier interesado a programar un cliente en qt, wx, o cualquier otro tipo de interfaz gráfica utilizando gecolib.