Esta entrada es sobre el sistema de ficheros ZFS, el mismo fue desarrollado por Sun (ahora Oracle) y tiene como fuerte preservar al integridad de la data. A pesar de ser código abierto, por incompatibilidad de licencias no puede ser incluido en el Kernel de Linux, pero sí su implementación usando fuse.

En mi caso necesito un sistema de archivos para mi información familiar, fotos, vídeos, música, etc. Mayormente los formatos que tengo ya tienen compresión por ellos mismos, por lo cual un sistema de archivos con compresión no me serviría de mucho, de hecho sería contraproducente ya que consumiría ciclos de CPU casi que por el gusto.

Para esta prueba vamos a usar un archivo común como disco, zfs permite usar discos, particiones o archivos. Primero creamos un archivo de 512MB:

# dd if=/dev/zero of=rawdisk.1 bs=4096 count=131072

Luego pasamos a crear nuestro pool o contenedor de volúmenes, en este caso no vamos a crear ningún volumen extra en él, lo usaremos tal cual:

# zpool create testpool /home/paco/zfs-test/rawdisk.1

Además de crear el sistema de archivos también lo monta en /testpool y lo deja listo para usar. La información del pool se almacena en /var/lib/zfs/.

Podemos ver el estado con:

# zpool status
 pool: testpool
 state: ONLINE
 scrub: none requested
config:

    NAME                             STATE     READ WRITE CKSUM
    testpool                         ONLINE       0     0     0
      /home/paco/zfs-test/rawdisk.1  ONLINE       0     0     0

errors: No known data errors

De momento todo bien, vamos a copiar unos archivos de imágenes en formato JPEG a /testpool/ para intentar simular corrupción de la data, una vez copiado los archivos pasaremos a desmontar la unidad:

# zfs unmount /testpool

Ahora modificamos algunos bytes de nuestro disco duro (rawdisk.1), las imágenes que copié tienen de encabezado las letras «JFIF», buscaremos esto en nuestra data y lo modificaremos un poco:

# hexdump -C rawdisk.1 | less 

0040ac00  ff d8 ff e0 00 10 4a 46  49 46 00 01 02 01 00 48  |......JFIF.....H|
0040ac10  00 48 00 00 ff e1 1d 7a  45 78 69 66 00 00 49 49  |.H.....zExif..II|
0040ac20  2a 00 08 00 00 00 0f 00  0f 01 02 00 09 00 00 00  |*...............|
0040ac30  c2 00 00 00 10 01 02 00  10 00 00 00 cb 00 00 00  |................|
0040ac40  12 01 03 00 01 00 00 00  01 00 00 00 1a 01 05 00  |................|

De «JFIF» vamos a cambiar «IF» por algo aleatorio, para ello usamos lo siguiente:

# echo $(((0x0040ac00)+8))
 4238344
# dd if=/dev/random of=rawdisk.1 seek=4238344  bs=1 count=2 conv=notrunc

La primera columna de la salida de hexdump muestra la posición (en hexadecimal) de la data, en nuestro caso 0x0040ac00 corresponde al byte «ff», de allí empezamos a contar, 1 es «d8», 2 es «ff», 3 es «e0» y así hasta llegar a «IF», que es 49 y 46 respectivamente (se puede comprobar con una tabla ascii, man ascii), la cuenta nos da 8, por lo cual convertimos a decimal y sumamos 8, luego ese valor es la posición (en bytes) desde la cual iniciaremos el daño.

Repetimos el proceso con otros JFIF y volvemos a cargar el sistema de archivos:

# zfs mount testpool

Verificamos su integridad (esto se ejecuta periódicamente, pero se puede hacer manual para adelantar el proceso):

# zpool scrub testpool

Y ahora:

# zpool status testpool   
  pool: testpool
 state: ONLINE
status: One or more devices has experienced an error resulting in data
    corruption.  Applications may be affected.
action: Restore the file in question if possible.  Otherwise restore the
    entire pool from backup.
   see: http://www.sun.com/msg/ZFS-8000-8A
 scrub: scrub completed after 0h0m with 2 errors on Fri Dec 14 23:59:27 2012
config:

    NAME                             STATE     READ WRITE CKSUM
    testpool                         ONLINE       0     0     2
      /home/paco/zfs-test/rawdisk.1  ONLINE       0     0     4

errors: 2 data errors, use '-v' for a list

¡Tenemos 2 errores!, hacemos caso y agregamos ‘-v’:

# zpool status -v testpool
  pool: testpool
 state: ONLINE
status: One or more devices has experienced an error resulting in data
    corruption.  Applications may be affected.
action: Restore the file in question if possible.  Otherwise restore the
    entire pool from backup.
   see: http://www.sun.com/msg/ZFS-8000-8A
 scrub: scrub completed after 0h0m with 2 errors on Fri Dec 14 23:59:27 2012
config:

    NAME                             STATE     READ WRITE CKSUM
    testpool                         ONLINE       0     0     2
      /home/paco/zfs-test/rawdisk.1  ONLINE       0     0     4

errors: Permanent errors have been detected in the following files:

        /testpool/1920-1200-11295.jpg
        /testpool/1920-1200-217.jpg

No solo se detectó el error, sino que también nos dice los archivos afectados. Los mismos no pueden ser recuperados y nos pide restaurar la copia de respaldo que no tenemos. Si hubiésemos creado dos discos y creado el pool como mirror, zfs los hubiera podido recuperar por nosotros.

La ventaja de tener este tipo de detección es que nos permite tomar acciones antes de que los errores destruyan más nuestra información.

Referencias:

1. ZFS en la wikipedia
2. Implementación de ZFS en Linux usando fuse
3. Guía de administración de ZFS (Solaris, en inglés)

La técnica pomodoro es un método para aumentar la productividad, concentración y enfoque, consiste en trabajar por 25 minutos, luego descansar 5 y repetir, al 4to ciclo en lugar de tomar una pausa de 5 minutos se toma una más amplia, de 15 o 20.

A continuación algunas aplicaciones para hacer el proceso más fácil:

• Tomighty
• Pomodoro app
• Pomodairo
• Focus booster

Vale la pena probarlo.

Llega el momento en que tienes un montón de vídeos, música y demás documentos que te gustaría compartir entre usuarios. Y es que con la llegada de televisores inteligentes, media boxes y demás artilugios resulta muy conveniente instalarse una media server (Media Tomb por ejemplo, o alguno de aquí) en la pc de casa y compartirlo todo con los demás dispositivos.

El problema llega cuando se tienen varios usuarios en dicha pc, como pasa en mi caso, cada integrante de la familia tiene una cuenta en la pc (o mejor dicho, mini servidor) de casa, estas personas tienen su contenido en sus directorios personales y eventualmente los compartirán con el directorio en el cual escucha el media server.

Aquí llegan los problemas con los permisos. Digamos que nuestro servidor UPnP (media server) exportará el contenido de /data por lo cual necesitamos que todo lo que llegue a ese directorio tenga permisos de lectura (y escritura, por si hace falta modificar algún id tag o algo) para el grupo que usaremos.

Primero creamos el grupo a usar:


# groupadd media


Creamos nuestros directorios:


# mkdir -p /data/Music
# mkdir -p /data/Videos
# mkdir -p /data/Pictures
# mkdir -p /data/Documents


Una vez que tenemos nuestra estructura de directorios principal, podemos pasar a definir permisos globales:


# chgrp -R media /data
# chmod -R /data
# chmod -R g+s /data


Con esto le damos permiso de lectura y escritura al dueño de los directorios (root, pero bien podría ser el usuario que usa nuestro UPnP), a los miembros del grupo media y a nadie más.

Ahora agregamos nuestros usuarios al grupo, pero nos encontramos que al copiar o mover archivos o directorios a /data/ se agregan con el grupo media pero con los permisos por defecto (umask) lo cual es un problema ya que los demás usuarios nos serán capaz de modificar los mismos.

En principio puede que esto no sea un problema, pero eventualmente lo será, imagine el caso en que el usuario1 convierte un cd de su artista favorito a ogg y lo agrega a /data/Music/ pero sin incluir los respectivos id tags, si el usuario2 se da cuenta de esto, tendrá que pedirle al usuario1 que lo modifique en lugar de poder hacerlo él mismo.

Para lidiar con esto hay dos posibles soluciones, usar bindfs o listas de acceso (ACL).

BindFS

BindFS es un sistema de archivos basado en FUSE que permite montar un directorio sobre otro modificando varios permisos. En el caso que dispongamos de él, podemos usarlo:


# bindfs --create-for-group=media -gmedia --create-with-perms=u+rw,g+rw,o-rwx -pu+rw,g+rw,o-rwx /data /data


Esto nos asegura que todos lo que se cree nuevo tendrá como grupo media (create-for-group) que el grupo con el cual se montará será media (g), que los permisos se mantendrán de escritura y lectura para el dueño y grupo (create-with-perms y p)

Ahora sólo debemos agregarlo a nuestro /etc/fstab con la siguiente línea:


bindfs#/data    /data    fuse    perms=u+rw:g+rw:o-rwx,create-with-perms=u+rw:g+rw:o-rwx,group=media,create-for-group=media    0    0


Listas de acceso

Las listas de control de acceso o atributos (permisos) extendidos se incluyeron a partir del kernel 2.6, las mismas permiten un mayor control de los permisos de cada archivo.

Para poder ser usadas nuestra partición debe estar montada con la opción acl (la cual debería ser por defecto), es posible usar el comando mount para comprobar las particiones que tenemos habilitadas:

<code
$ mount | grep acl

El comando a usar para modificar dichos permisos es setfacl y en nuestro caso podríamos usarlo de la siguiente forma:


# setfacl -R -d -m u::rw,g::rw,g:media:rwx,o::- /data


¡Y ya está!

Desde usuarios regulares hasta administradores de sistema casi siempre ocurre que debemos ingresar de forma remota a otro equipo, el protocolo/aplicación de-facto para dicha tarea es SSH, el cual nos permite ingresar con un usuario y contraseña a equipos remotos.

Muchas veces ingresamos con frecuencia a los mismos equipos o nos gustaría tener más seguridad que simplemente un usuario y contraseña. Para eso podemos usar llaves criptográficas, este artículo asume que usted está en el equipo ClienteA y cuenta con una cuenta en el ServidorB al cual desea ingresar.

Lo primero es crearnos un juego de llaves, se le denomina juego de llaves porque consta de una llave pública y una privada, como su nombre lo indica la pública se puede compartir y la privada no.

Para eso ingresamos (en caso que no estemos ya allí), a nuestro equipo, ClienteA y ejecutaremos:

[paco@ClienteA ~]$ ssh-keygen -t rsa

Seguimos las instrucciones y si no queremos ingresar una contraseña pues no lo hacemos, la dejamos en blanco y confirmamos dos veces, esto nos debería crear algo más o menos así:

[paco@ClienteA ~]$ ls .ssh/
id_rsa       id_rsa.pub     known_hosts

El fichero id_rsa contiene nuestra clave privada, el id_rsa.pub nuestra pública y el known_hosts no es importante.

Ahora tenemos que pasar nuestra llave pública al equipo remoto, como tenemos trastornos de personalidad, nuestro usuario allá se llama frank, por lo cual:

[paco@ClienteA ~]$ ssh frank@ServidorB mkdir -p .ssh

Con esto creamos el directorio (/home/frank/.ssh) en el ServidorB si ya existe pues no pasa nada.

Como último paso copiamos nuestra llave pública a la lista de llaves aceptadas en ServidorB para ello:

[paco@ClienteA ~]$ cat .ssh/id_rsa.pub | ssh frank@ServidorB 'cat >> .ssh/authorized_keys'

Luego de esto confirmamos que podemos ingresar sin contraseña (de no haber especificado ninguna) así:

[paco@ClienteA ~]$ ssh frank@ServidorB
[frank@ServidorB ~]$

¡Listo!

Existen varias soluciones en Linux para llevar un control de, ya sea la contabilidad personal o la de algún negocio. Entre los más populares está GnuCash el cual he usado en el pasado pero nunca terminó de gustarme del todo.

Los que llevan algo de tiempo leyéndome sabrán que soy un usuario de Emacs y fanático de los archivos de texto.

La aplicación que cumple con esto se llama ledger es una aplicación de texto que lee, procesa y reporta transacciones en un archivo de texto. Lo bueno de ledger es que no modifica ni altera la data de ninguna forma, la data (y por data me refiero a transacciones) se mantienen en el archivo de texto plano que se proporcione.

El formato de dicho archivo es bastante simple:

2012/01/29 Slackware Store
    Gastos:Ropa              $ 15.00
    Deudas:Visa

2012/01/29 Pago a VISA
    Deudas:Visa              $ 15.00
    Bienes:Banco:Chequera


Aquí tenemos dos transacciones, la primera es una compra usando la tarjeta de crédito y la segunda es un pago/abono a la cuenta de dicha tarjeta. Como se puede apreciar, los nombres de las categorías y subcategorías los inventa uno, basta con que sean separados por ‘:’ por lo cual tenemos flexibilidad total.

Como es de esperar junto con la aplicación viene un modo para emacs ‘ledger-mode’ el cual facilita el ingreso de transacciones y al estar todo en un archivo de texto plano lo que importa es dicho archivo (que fuera del formato usado, poco tiene que ver con la aplicación en si), por lo cual el mismo puede ser modificado desde cualquier punto siempre que se cuente con una conexión ssh y un editor de texto.

La aplicación (ledger) será usada sólo al momento de analizar la data, ver los balances, revisar presupuesto, etc, etc.

Lo que yo hago es que tengo mi archivo en un repositorio con git lo cual me permite sincronizar los cambios desde distintas ubicaciones y para tenerlo todo en un lugar seguro en caso de catástrofe uso un repositorio git privado en bit bucket pero hay muchos más que ofrecen repositorios privados de forma gratuita.

Si está buscando una forma de llevar el control de sus finanzas, hacer presupuestos y demás, debe probar ledger.

Referencias:

• La wiki de Ledger en git hub
• Sitio oficial de Ledger

La seguridad es un tema que todo usuario debe tener presente, siempre que maneje información medianamente importante.

Existen varias soluciones para cifrar información en Linux, quizás la más común es cifrar toda una partición. El problema con esto es que en muchos casos o nos quedamos sin espacio o bien lo desperdiciamos y aunque existen soluciones para aumentar y/o disminuir el tamaño de las particiones de forma más dinámica como LVM la tarea puede llevar algo de riesgo.

eCryptFS

Una posible solución es usar eCryptfs, el cual es un sistema de archivos cifrado y el mismo está contenido en un directorio. Es decir, es un directorio que es «montado» como un dispositivo de almacenamiento, todo lo que se escriba o lea de él se cifrará de manera transparente. Una vez desmontado el mismo la información estará cifrada.

Para preparar un directorio de prueba:

$ mkdir secret
# mount -t ecryptfs secret/ secret/


Se deben recordar los parámetros usados para la próxima vez que se monte.

EncFS

EncFS es otra opción, la misma no requiere ser root ni hacer un suid del mount.

Para usarlo, una vez instalado, ejecutamos lo siguiente:

$ mkdir secret-raw
$ mkdir secret
$ cd secret
$ echo "probando con una línea de texto" > archivo.txt
$ cat archivo.txt
probando con una línea de texto
$ fusermount -u secret
$ cd secret-raw
$ ls
0QOUfazjVWTUASS1,IGYuJ3m
$ cat 0QOUfazjVWTUASS1,IGYuJ3m
�Q^�V-���+wI�$�kZz�㈎zQ '/�.y8��


Se creará un fichero en ~/secret-raw/.encfs6.xml con toda la información seleccionada al momento de crear el volumen, es importante mantener una copia del mismo (protegida).

Notas

Como nota extra es importante recordar que debemos (en la medida de lo posible) cifrar la partición swap. La razón es por la posibilidad que el sistema operativo escriba el contenido de memoria en dicha partición. El atacante podría revisar la información en la partición swap en busca de llaves o información del contenido cifrado.

Para cifrar la partición swap lo mejor es usar dm-crypt, como la data sólo es importante durante la sesión, no es necesario especificar una llave ya que puede ser escogida al azar al inicio.

Lo mejor es seguir la documentación de la distribución que se esté usando para cifrar la partición swap.

Emacs es un editor de texto de culto, en mi opinión, lo mejor que hay para programar, es todo un IDE, la cantidad de funciones que tiene y puedes agregar va de lo sublime a lo ridículo. Sigue leyendo →