# rm-rf.es | Administración de sistemas

Bitácora personal de un SysAdmin Gnu/Linux, Windows, BSD...

Encriptar un filesystem con LUKS y cryptsetup


luksLUKS (Linux Unified Key Setup) es un cifrado que trabaja a nivel de bloque de fichero sobre la partición o volumen lógico y que permite encriptar sistemas de ficheros, para los cuales es necesaria una passphrase o keyfile para su desencriptado. Encriptar un sistema de ficheros es especialmente útil cuando trabajamos con información sensible en dispositivos físicos portatiles, como por ejemplo pendrives, ordenadores portátiles, etc.

Vamos a encriptar un sistema de ficheros de un disco secundario sobre un sistema RHEL 6 (CentOS). Para encriptar particiones de sistema (filesystem / o /home por ejemplo) es preferible hacerlo en el momento de la instalación, ya que resulta más sencillo y evitamos la pérdida de datos posterior.

Preparación del sistema

Para la encriptación con LUKS necesitamos tener cargado el módulo de kernel dm_crypt así como el paquete cryptsetup-luks:

# lsmod | grep dm_cry
dm_crypt               10848  0
dm_mod                 63859  5 dm_crypt,dm_mirror,dm_log

Si no está cargado en vuestro sistema hacedlo con modprobe:

# modprobe dm_crypt

Acordaos de configurarlo (por defecto es probable que con modprobe sea suficiente) para que sea persistente a reinicios.

Instalamos cryptsetup-luks en caso de que no esté instalado:

# yum install cryptsetup-luks
# rpm -qa | grep cryptse
cryptsetup-luks-libs-1.1.2-2.el6.i686
cryptsetup-luks-1.1.2-2.el6.i686

Preparación del sistema de ficheros/partición

Vamos a asumir que tenemos ya el sistema de ficheros creado. Podéis revisar los siguientes artículos si tenéis dudas, tanto de crear una partición estándar como un LVM:

Algo recomendable pero que suele llevar bastante tiempo es, lo primero de todo, llenar de datos aleatorios la partición a encriptar. Repito que puede llevar bastante tiempo dependiendo del tamaño de la partición. Si sólo estáis haciendo pruebas no es necesario que lo hagáis (sustituid /dev/volgroup1/logvol1 por vuestra partición o volumen):

# dd if=/dev/urandom of=/dev/volgroup1/logvol1

Encriptación del filesystem

Llegados a este punto ya tenemos el sistema de ficheros preparado para su encriptación. Haremos uso del comando cryptsetup. Lo primero que haremos es asignar la passphrase. Cuanto más compleja sea mejor, igual que cualquier password:

Nota: se eliminará cualquier dato del filesystem

# cryptsetup luksFormat /dev/volgroup1/logvol1

WARNING!
========
This will overwrite data on /dev/volgroup1/logvol1 irrevocably.

Are you sure? (Type uppercase yes): YES
Enter LUKS passphrase: *********
Verify passphrase: *********

Al tratarse de un filesystem encriptado debemos mapearlo ya que no se puede leer directamente. Esa unidad mapeada será la que montaremos y utilicemos como un filesystem estándar. Vamos a sacar el UUID del sistema de ficheros encriptado para utilizarlo si queremos en lugar de la etiqueta (LABEL):

# cryptsetup luksUUID /dev/volgroup1/logvol1
79da86ea-70f2-4a80-82cb-6c614a885a37

Mapeamos el sistema de ficheros contra encrypted-fs:

# cryptsetup luksOpen /dev/volgroup1/logvol1 encrypted-fs
Enter passphrase for /dev/volgroup1/logvol1:

Y ya tenemos el volumen listo para particionar en /dev/mapper/encrypted-fs. Le damos formato y lo montamos:

# mkfs.ext4 /dev/mapper/encrypted-fs

Finalmente, lo añadimos a fstab para el arranque al inicio del sistema. Podemos hacerlo con el UUID o con la etiqueta (LABEL) del fs:

# tune2fs -l /dev/mapper/encrypted-fs | grep UUID
Filesystem UUID:          9578a03e-949b-4fe8-a16c-57024b01fe89

Lo añadimos a /etc/fstab:

UUID=9578a03e-949b-4fe8-a16c-57024b01fe89 /encrypted-fs ext4    defaults 0 0

Y añadimos también la siguiente entrada a /etc/crypttab para que solicite la passphrase en el arranque del sistema:

encrypted-fs /dev/volgroup1/logvol1 none

Si reiniciáis, durante el arranque se os solicitará la passphrase del volumen:

logvol1 is password protected: *************

Encriptación y desencriptación con GnuPG


Gracias a la herramienta GnuPG la encriptación de datos y creación de firmas digitales se convierte en una tarea relativamente sencilla. Disponemos de una serie de utilidades para la creación, importación y exportación de keys y por supuesto para la encriptación/cifrado y desencriptación de ficheros.

Lo primero que debemos hacer es instalarla en el sistema, para ello simplemente haced uso de cualquier sistema de gestión de paquetes (yum, apt) e instalar GnuPG.

Una vez instalado, deberíamos comenzar con los siguientes pasos y tareas básicas:

Creación de un nuevo key-pair

Generaremos nuestra pareja de llaves (pública y privada), que posteriormente utilizaremos para la encriptación de ficheros, utilizaremos el siguiente comando:

# gpg --gen-key

Hemos de responder a las distintas preguntas del asistente que aparece, podemos establecer de momento por defecto el tipo de llave, su tamaño y expiración, hemos de rellenar posteriormente nuestro nombre real, comentario con el que identificaremos la llave y nuestro email. La salida podría ser similar a lo siguiente:

gpg (GnuPG) 1.4.10; Copyright (C) 2008 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Por favor seleccione tipo de clave deseado:
   (1) RSA y RSA (predeterminado)
   (2) DSA y Elgamal
   (3) DSA (sólo firmar)
   (4) RSA (sólo firmar)
¿Su selección?: 1
las claves RSA pueden tener entre 1024 y 4096 bits de longitud.
¿De qué tamaño quiere la clave? (2048)
El tamaño requerido es de 2048 bits
Por favor, especifique el período de validez de la clave.
         0 = la clave nunca caduca
        = la clave caduca en n días
      w = la clave caduca en n semanas
      m = la clave caduca en n meses
      y = la clave caduca en n años
¿Validez de la clave (0)?
La clave nunca caduca
¿Es correcto? (s/n) s

Necesita un identificador de usuario para identificar su clave. El programa
construye el identificador a partir del Nombre Real, Comentario y Dirección
de Correo electrónico de esta forma:
    "Heinrich Heine (Der Dichter) "

Nombre y apellidos: Heinrich Heine
Dirección de correo electrónico: heinrichh@duesseldorf.de
Comentario: Der Dichter
Ha seleccionado este ID de usuario:
    «Heinrich Heine (Der Dichter) »

¿Cambia (N)ombre, (C)omentario, (D)irección o (V)ale/(S)alir? V
Necesita una frase contraseña para proteger su clave secreta.

gpg: el agente gpg no esta disponible en esta sesión
No ha especificado contraseña. Esto es probablemente una *mala* idea.
Si más tarde quiere añadir una, puede hacerlo usando este programa con
la opción "--edit-key".

Es necesario generar muchos bytes aleatorios. Es una buena idea realizar
alguna otra tarea (trabajar en otra ventana/consola, mover el ratón, usar
la red y los discos) durante la generación de números primos. Esto da al
generador de números aleatorios mayor oportunidad de recoger suficiente
entropía.
..........
+++++

gpg: clave CD0E7A06 marcada como de confianza absoluta
claves pública y secreta creadas y firmadas.

gpg: comprobando base de datos de confianza
gpg: 3 dudosa(s) necesarias, 1 completa(s) necesarias,
modelo de confianza PGP
gpg: nivel: 0  validez:   5  firmada:   0  confianza: 0-, 0q, 0n, 0m, 0f, 5u
pub   2048R/CD0E7A06 2010-11-19
      Huella de clave = C079 7D5D AD34 A0CA E9B6  B895 29B5 36CC CD0E 7A06
uid                  Heinrich Heine (Der Dichter)
sub   2048R/FD47C2FB 2010-11-19

Importar y exportar keys

Tras crear nuestra llave, podemos importarla o exportarla en distintos equipos, desde los que tenemos intención de compartir ficheros encriptados, para importar una llave ejecutamos:

# gpg --import Public-key.asc

Podemos exportar nuestra key del siguiente modo (ascii), luego podríamos utilizar el comando anterior para importarla en otro equipo. –ascii crea una salida ascii con armadura.

gpg --export --armor > Public-key.asc

Una vez importada la key en nuestro sistema, conviene firmarla para verificar la veracidad de la llave, utilizaremos el siguiente comando, donde UID es el ID/nombre de la llave.

gpg --sign-key 'UID'

Encriptar y desencriptar

Una vez que tenemos la llave creada, instalada y firmada en el sistema, ya podemos empezar a encriptar y desencriptar ficheros. En el siguiente ejemplo vamos a encriptar un fichero de texto, los parámetros indican que se firma y cifra (-ser) para el usuario con su determinado UID/nombre creando una salida ascii con armadura (-a). tendremos que escirbir la frase contraseña de la llave para hacer efectivo el cifrado:

# gpg -sear 'UID' test2.txt

Necesita una frase contraseña para desbloquear la clave secreta
del usuario: "xxxx xxxx (xxx xxx) "
clave DSA de 2048 bits, ID 7EEECF36, creada el 2010-11-08

gpg: el agente gpg no esta disponible en esta sesión
Introduzca frase contraseña: 

Para hacer el proceso inverso de descifrado, utilizaríamos el siguiente comando, donde -d indica desencriptar y mensaje-cifrado.asc es el fichero generado en el anterior comando, que guardaremos en salida.txt:

# gpg --output salida.txt -d mensaje-cifrado.asc 

El proceso de desencriptar ficheros de equipos remotos es el mismo siempre que haya sido encriptado utilizando tu misma llave pública.

La gestión básica de llaves resumiría los siguientes comandos:

Listar las llaves instaladas en el sistema:

# gpg --list-keys

Borrar llave “test@test.com” instalada en nuestro sistema:

gpg --delete-key 'test@test.com'

Esto es simplemente un acercamiento al uso básico de gnuPG. Para profundizar más en este tema, os recomiendo revisar las siguientes referencias:

Documentación oficial GNnuPG
Guía GnuPG de tldp.org

Perl: Encriptar y desencriptar base64 con MIME::Base64


El módulo de Perl MIME::Base64 proporciona funciones para codificar y descodificar cadenas en y desde base64.

Base 64 es un sistema de numeración posicional que usa 64 como base. Es la mayor potencia de dos que puede ser representada usando únicamente los caracteres imprimibles de ASCII. Esto ha propiciado su uso para codificación de correos electrónicos, PGP y otras aplicaciones. Todas las variantes famosas que se conocen con el nombre de Base64 usan el rango de caracteres A-Z, a-z y 0-9 en este orden para los primeros 62 dígitos, pero los símbolos escogidos para los últimos dos dígitos varían considerablemente de unas a otras. Wikipedia

Las funciones que nos ofrece son las siguientes:

encode_base64($str);
encode_base64($str, $eol);
decode_base64($str);

Os dejo un par de ejemplos muy sencillos, podéis encontrar más en cPan.org.

Decodificación:

#!/usr/bin/perl
use warnings;
use strict;
use MIME::Base64;

my $string_codificada = "RXN0byBlcyB1bmEgcHJ1ZWJh";
my $string = decode_base64($codificado);
print "String ($string_codificada) decodificada:\n ".$string;

Codificación:

#!/usr/bin/perl
use warnings;
use strict;
use MIME::Base64;

my $string = 'Esto es una prueba';
my $string_codificada = encode_base64($string);
print "String ($string) codificada:\n".$string_codificada;

Encriptar mensajes de Gmail con FireGPG


Gmail Encrypt

Últimamente no tengo demasiado tiempo para publicar artículos, no obstante os voy a ir dejando enlaces curiosos y de utilidad, por supuesto seguiré posteando cuando sea posible, normalmente cada uno o dos días.

Hoy os dejo un enlace en el que explican como encriptar los mensajes que enviamos a través de Gmail, se hace con la extensión de Firefox FireGPG

Podéis leer el artículo si queréis pinchando aquí (Inglés)