Jugando con MongoDB y Python

Bien, siguiendo el post anterior, vamos a cargar de GeoNames todos los datos sobre España en una base de datos MongoDB. Aqui no se va a explicar como instalar un servidor de Mongo. Se pueden encontrar todas las indicaciones en su pagina web oficial si no sabes que es Mongo, visita esta página. No es nada complicado. Bien, al lío.

Primero tenemos que ir a GeoNames ir a la parte de "descargas" y bajarnos algún país. En mi caso me he descargado ES.txt, documento que contiene todos los todos sobre España. Descomprimido, el fichero pesa unos 6.8MiB. Bien, ahora tenemos que "meterlo" en la base de datos. Lo podemos hacer así:


#! /usr/bin/env python
# -*- coding: utf-8 -*-
#Filename: buscar.py
#Filename: cargar_datos.py
from pymongo.connection import Connection
#Abrimos una conexión con la BBDD de mongo y creamos una colección llamada ES.
connection = Connection()
db = connection.ES
collection = db.ES
#Estos son los campos que contiene el fichero
fields = [
"geonameid",
"name",
"asciiname",
"alternatenames",
"latitude",
"longitude",
"feature_class",
"feature_code",
"country_code",
"cc2",
"admin1_code",
"admin2_code",
"admin3_code",
"admin4_code",
"population",
"elevation",
"gtopo30",
"timezone",
"modification_date"
]

#Abrimos el fichero de datos
file = open('ES.txt', 'r')
#Insertamos todos los datos en la BBDD. Simple y llanamente.
for data in file:
collection.insert(dict(zip(fields, data.split('\t'))))
print 'Done! =)'
#Cerramos el fichero y la conexión.
file.close()
connection.disconnect()

Bien, señores. Ahora solo queda ejecutar el comando con un simple "python cargar_datos.py". En mi ordenador, el proceso tarda unos 25 segundos, aproximadamente. Carga 58.317 registros ( llamados documentos, en la jerga de Mongo ).
Y ya tenemos todos los datos en la BBDD!!

Pero claro, ahora con todos estos datos que hacemos? Pues vamos a crear un pequeño codigo para hacer consultas:
#! /usr/bin/env python
# -*- coding: utf-8 -*-

import pymongo
import re
import sys
#Nos conectamos a la BBDD, a la colección ES
db = pymongo.Connection().ES
collection = db.ES

#Cogemos el primer argumentos que nos han pasado como parámetro
busca = sys.argv[1]
#Compilamos una expresión regular para la búsqueda
regex = re.compile(busca)
#Buscamos en la base de datos la expresión regular en el campo "alternatenames". Los resultados los guardamos en una lista.
resultados = [ n for n in collection.find({"alternatenames":regex})]
#Por cada elemento de la lista pintamos los siguientes datos.
for tupla in resultados:
print ">Nombre:",tupla["name"]
print "Nombres comunes:",tupla["alternatenames"]
print "Coordenadas [Longitud][Latitud]:", tupla["latitude"], tupla["longitude"]
print "Link:", "http://maps.google.com/?ie=UTF8&ll=" + str(tupla["latitude"]) + "," + str(tupla["longitude"]) + "&spn=0.047113,0.109863&t=h&z=12"
print "Resultados encontrados:", len(resultados)
print ""


Como funciona el programa? Muy simple:
$ python buscar.py Pollença
Y esto nos va a dar los resultados. Si usamos una terminal Bash, podemos hacer clic con Control pulsado sobre el link y automáticamente se abrirá en Google Maps el la posición exacta del lugar buscado. Espero que se haya entendido algo =). No dejen de postear sus dudas/mejoras. Gracias!

Borrado seguro de ficheros TrueCrypt con Python [II]

Jugando, he ido mejorando el cachito de codigo que había creado hace poco. De las 15 lineas y aparente inutilidad, ahora tenemos 10 vezes más líenas y es igual de inútil. Pero hace más cosas!! =)

Para ver mas o menos para que sirve el programa, revisar el el primer link, aún así hago un poquito de resumen: Tenemos ficheros TrueCrypt con datos cifrados. Si queremos borrar todos los datos del volúmen, no hace falta sobreescribir todo el volumen varias veces, solo necesitamos borrar los primeros 65.536 bytes de manera segura para dejar inútil el volumen. Os muestro un poquito como funciona el programilla, que por cierto lo he llamado tcrm (TrueCryptReMover). Original? no. Facil de recordar? si ;)

Para descargar programa, click aqui.

Primero tenemos que crear un fichero donde guardaremos las rutas de nuestros containers truecrypt. Cuando ejecutemos el programa tcrm, estos ficheros serán borrados. El fichero, llamado "lista.list" puede ser como el siguiente:

# Check
./tc_container
./tc_container2
./tc_con
./tc_con1

Vale, tenemos lo siguiente. La primera línea "# Check", sirve como control del programa para ver si está cifrado o los datos están en claro. Siempre se debe incluir en el fichero. La palabra en cuestión es facilmente configurable desde el programa tcrm.

Después hay un listado de volúmenes TrueCrypt. Les he puesto estos nombres, pero podrían ser cualquier otros. Aqui puede venir una ruta absoluta o relativa, como se desee. Estos ficheros serán machacados, si se ejecuta el programa. (si algún usuario "windows" me lee, aquí no hay un Control+Z... cuando digo que se borran, no bromeo :P)

Ahora ya tenemos creado nuestro ficherito que apunta a cada uno de los volúmenes que queremos borrar de manera segura. Vamos a ver el ejecutable:
$ ./tcrm --help
-h --help Imprime esta ayuda
-c --cipher Cifra el fichero pasado como parámetro
-d --decipher Descifra el fichero pasado como parámetro
-t --try Comprueba que los volúmenes especificados pueden borrarse
-k --kill Ejecuta el algoritmo de borrado

Pues básicamente tenemos 4 opciones:

• --cipher: para cifrar el fichero "lista.list", de modo que no se vea la ruta donde nosotros guardamos cada uno de nuestros ficheros TrueCrypt
• --decipher: para descifrar un fichero ya cifrado. Por si queremos añadir volúmenes adicionales o quitar volúmenes ya existentes en la lista.
• --kill: abre la "lista.list" y por cada ruta de volúmen, le aplica un borrado Gutmann sobre los primeros 65.536 bytes. Los volúmenes serán imposibles de recuperar.
• --try: hace un simulacro de borrado. Descifra el fichero "lista.list" y intenta leer cada uno de los volúmenes. Útil para comprobar tema de permisos, etc...

Un ejemplo: Imaginemos que tenemos el fichero "lista.list de antes.
$ ./tcrm --decipher lista.list
> Password: [ponemos nuestra password]

Así ya tenemos nuestra lista cifrada y nadie puede saber dónde guardamos nuestros volúmenes TrueCrypt. Ahora vamos a borrar:
$ ./tcrm --kill lista.list
> Password: [ponemos el password anterior]
> Procesando el fichero "./tc_container"...
> Procesando el fichero "./tc_container2"...
> Procesando el fichero "./tc_con"...
> Procesando el fichero "./tc_con1"...

Amén. Nadie volverá a acceder a los datos de los containers.

Seguridad? Si, dejadme que os cuente un poco.
Cuando introducimos nuestra clave, hacemos un hash SHA512. Diez mil vezes. Para que? Bueeeno, tiene una explicación. Esto no hace más seguro nuestro sistema, sinó que simplemente dificulta 10.000 veces, el posible ataque por fuerza bruta, que serviría para descifrar nuestro fichero y conocer la clave con la que lo hemos cifrado. Para poner un ejemplo fácil: si en un ataque de fuerza bruta se pudiese sacar el password en 10 segundos, con este "inventito" retrasaríamos el ataque hasta 27 horas, para conseguir lo mismo. Una ataque de una hora, ahora duraría un año y un par de meses. Hay que decir que para romer un solo hash de 512 bits se pueden necesitar varios miles de años.

Y después está el cifrado del fichero, que se hace con criptografía simétrica, utilizando el algorítmo AES con una clave de 256 bits (clave resultante de la función de hash mencionada). Para poner otro ejemplo AES256 es el nivel de seguridad que utilizan deteminados gobiernos para sus documentos clasificados y top-secret. Si es bueno para ellos, también lo será para nosotros ^^

Un fallo tremendamente grande, es que el programa está hecho en python, y en texto claro. Por esto es facilmente modificable. Pero bueno, así ya se que tengo que ir mejorando para la próxima entrega del algorítmo.

Nota: sería estupendo recibir críticas a saco: buenas o malas. Si me he dejado algo en la seguridad del programa, si la implementación no es buena, si las notas en inglés estan demasiado mal o cualquier cosa que os parezca que se tiene que cambiar/mejorar.

Saludos!

Problema de las N Reinas

Bueno, hecho el post anterior, quiero subir un poquito de código sobre GA. El algorítmo es para solucionar el problema de las N Reinas. El enunciado es el siguiente:

Dado un tablero de ajedrez de NxX colocar N reinas sin que se maten entre ellas.

En principio N és igual a 8, ya que así representamos un tablero de ajedrez normal. Éste problema puede ser resuelto mediante backtracking, y es tremendamente más eficaz que con los GA, pero como la intención es practicar con los algoritmos genéticos, en problema de las N Reinas es suficientemente fácil para empezar. Hay 92 posibles soluciones posibles al problema dado, pero tansolo 12 soluciones únicas ( lo que significa que las otras són combinaciones de éstas mismas )

Implementación en Python del problema de las N Reinas

Disclaimer: Esto lo hago en mi tiempo libre, no tengo a nadie que me instruya ni nadie que me corrija mis fallos. Por esto mismo, seguro que hay mejores implementaciones del código. Pero invito ( o reto ) a que alguien corrija el código, lo modifique a su gusto y lo mejore, y haber si entre todos aprendemos algo =)

Si conces algún sitio donde se pueda encontrar buena documentación o datos relacionados sobre los GA, deja tu comentario please.

Borrado seguro de ficheros TrueCrypt con Python

[Estoy jugando con un script en Python para borrar volúmenes TrueCrypt de manera segura, si te interesa, sigue leyendo]
Crees que estás siendo seguido por el FBI o tienes pruebas sobre la muerte de JFK que implican a Obama, el Dalail Lama i al Monstruo de las galletas o un colección estupenda de películas de dudosa reputación que no quieres que nadie vea?? Pues TrueCrypt es tu programa. Gratis, Open-Source y aplicando un nivel de criptografía prohibido en algunos paises ( EEUU, por ejemplo ) es una de tus mejores opciones para ocultar información en contenedores. How-To de TrueCrypt hay muchos, aquí listo un par:

• La comunidad de DragonJar: explicación completa
  
• Security By Default: Cifrado de todo el disco, en 20 pasos

Voy a explicar un poquito cómo funcionan los volúmenes virtuales para entender luego como podemos hacer un borrado seguro quedando los datos irrecuperables. Vamos al lío.
Cuando creamos un contenedor TrueCrypt ( veeenga, revisar los links anteriooores ), se genera un fichero en nuestro sistema, que contiene todo un sistema de ficheros. Cuando está desmontado, los datos están cifrados pero si montamos el volumen -poniendo el password, claro- , todos estos datos se descifran a medida que se van necesitando, en tiempo real. El caso es que los primeros 65.536 bytes de cada contenedor, son cabezeras de información, que indican a TrueCrypt cómo montar el volumen. Sin esta información TrueCrypt no tiene ni idea de cómo montar el sistema de ficheros. Vale, y? ¬¬

Supongamos que queremos borrar todo un container TrueCrypt, pero que éste tiene un peso de 4.7GB. Si lo borramos de modo seguro con el algorítmo Gutmann, por ejemplo, se harán 35 pasadas. Osea, se sobreescribirá la información 35 vezes, o lo que es lo mismo... escribiremos en disco 164GB de información, para sobreescribir todos los datos. Esto puede tardar un poquito, y podemos hacerlo mucho más rápido tal que así.

Solución. Un pequeño algorítmo en Python que nos machaca la cabezera de un volumen TrueCrypt con el algoritmo Gutmann. Util? no creo. Seguro? Mucho.

#! /bin/python
import os
#constantes
FILE='container'
#Creación de valores aleatorios
rnd = lambda : str(os.urandom(3))
print 'Generando datos de sobreescritura con la secuencia Gutmann...'
data = [ rnd(), rnd(), rnd(), rnd(), '\x55', '\xAA', '\x92\x49\x24', '\x49\x24\x92', '\x24\x92\x49', '\x00', '\x11', '\x22', '\x33', '\x44', '\x55', '\x66', '\x77', '\x88', '\x99', '\xAA', '\xBB', '\xCC', '\xEE', '\xFF', '\x92\x49\x24', '\x49\x24\x92', '\x24\x92\x49', '\x6D\x86\xD8', '\xD6\xDB\x6D', '\xDB\x6D\xB6', rnd(), rnd(), rnd(), rnd(), ]
print 'Abriendo el fichero...'
f = open(FILE, mode='r+b')
print 'Escribiendo datos...'
for loop in data:
>>>>f.seek(0)
>>>>f.write(loop*65536) if len(loop) == 1 else f.write(loop*21845)
print 'Cerrando fichero...'
f.close()
print 'Done!'

Tanta explicación para este cachito de código? Pozí. Pero esto solo es el principio, espero mejorar el algorítmo un poquito. Lo siguiente será crear un fichero protegido que contenga una lista de ficheros que borrar, y quitar así la variable FILE, automatizando el proceso un poquitín más.