Zonas de OpenIndiana para Dummies

Recupero el blog, que lleva abandonado demasiado tiempo, para poner el primer capítulo de mi “Zonas de OpenIndiana para Dummies”

¿Qué es la zona? “Zones”, en su nombre en inglés, es un sistema de virtualización que crearon en Solaris 10 y que fue extendido en OpenSolaris y de ahí pasó a ser parte de Illumos, el kernel del proyecto OpenIndiana y otras distribuciones basadas en este experimentadísimo y muy estable UNIX System V.

Como la teoría está suficientemente explicada en las webs oficiales de los diferentes proyectos vamos a ir a un caso práctico.

Pongamos que tengo un ordenador, un portátil sin demasiados recursos, por cierto, en el que he instalado la versión Hipster 2016.10 de OpenIndiana. El nombre de la máquina es Arin. En ella vamos a crear una primera zona llamada Black que va a ser igual que Arin. Hago esta apreciación porque en futuras entregas haremos una zona Linux en OpenIndiana.

Vamos a empezar por unos conceptos prácticos y recomendaciones:

  1. Os animo a trastear un poco con el sistema de archivos ZFS para pillar un poco de soltura.
  2. Lo óptimo sería meter las Zonas en un pool de discos duros segregado del que contiene la zona global. En este caso va todo en el mismo disco duro pero las instrucciones no variarían mucho. Solo habría un comando más para crear el pool

Así que vamos a ponernos manos a la obra:

Paso 1.- Creamos una particion para contener todas las zonas

Primero vemos como se llama el pool de discos duros (o disco duro en mi caso) en el que vamos a crear el nuevo sistema de archivos. Para ello ejecutamos

starman@arin:~$ zfs list
NAME                         USED  AVAIL  REFER  MOUNTPOINT
rpool                       13,1G  94,4G  32,5K  /rpool
rpool/ROOT                  9,05G  94,4G    23K  legacy
rpool/ROOT/openindiana      12,4M  94,4G  6,01G  /
rpool/ROOT/openindiana-1    9,04G  94,4G  6,63G  /
rpool/dump                  1,85G  94,4G  1,85G  –
rpool/export                 177M  94,4G    23K  /export
rpool/export/home            177M  94,4G    23K  /export/home
rpool/export/home/starman    176M  94,4G   176M  /export/home/starman
rpool/swap                  1,97G  95,0G   164M  –

Creamos el sistema de archivos, al que vamos a llamar “zones” y lo montamos directamente en el raiz

zfs create rpool/zones
zfs set mountpoint=/zones rpool/zones

Paso 2.- Creamos un interface de red virtual

Podemos consultar los interfaces físicos de red con

starman@arin:~$ dladm show-phys
LINK         MEDIA                STATE      SPEED  DUPLEX    DEVICE
rge0         Ethernet             up         100    full      rge0

Creamos el interface de red virtual asociándolo al real y vemos que se ha creado correctamente

dladm create-vnic -l rge0 vniczone2
dladm show-vnic

Paso 3.- Creamos un fichero de configuración de la zona

Las zonas se puede configurar, siempre que estés paradas, mediante el comando zonecfg. En el caso de que, por necesidad de cualquier tipo, tuviéramos que crear varias zonas con características similares, podemos usar un fichero de configuración del este estilo:

starman@arin:~$ cat black.conf
create -b
set zonepath=/zones/black
set ip-type=exclusive
set autoboot=false
add net
set physical=vniczone2
end
commit

En este archivo estamos  indicando que la zona estará almacenada en el sistema de archivos que creamos en el primer paso y que usa la red virtual que hemos creado en el segundo paso. Al hacer el timpo “exclusive” estamos haciendo que no comparta IP con el sistema anfitrión, de modo que, desde fuera, parecerá un ordenador más de la red

Creamos la zona ejecutando el siguiente comando

zonecfg -z black -f black.conf

Y procedemos a instalarla

zoneadm -z black install

En este momento, si vuestro PC es tan lento como el mio, es cuando podéis aprovechar para hacer la colada o alicatar el baño.

Una vez haya terminado podemos ver que está instalada y que se ha creado un sistema de ficheros dentro de /zones que contiene toda la información de nuestra zona

starman@arin:~$ zoneadm list -v
ID NAME             STATUS     PATH                           BRAND    IP
0 global           running    /                              ipkg     shared
starman@arin:~$ zfs list
NAME                         USED  AVAIL  REFER  MOUNTPOINT
rpool                       14,3G  93,2G  32,5K  /rpool
rpool/ROOT                  9,05G  93,2G    23K  legacy
rpool/ROOT/openindiana      12,4M  93,2G  6,01G  /
rpool/ROOT/openindiana-1    9,04G  93,2G  6,63G  /
rpool/dump                  1,85G  93,2G  1,85G  –
rpool/export                 177M  93,2G    23K  /export
rpool/export/home            177M  93,2G    23K  /export/home
rpool/export/home/starman    177M  93,2G   177M  /export/home/starman
rpool/swap                  1,97G  95,0G   164M  –
rpool/zones                 1,27G  93,2G    23K  /zones
rpool/zones/black           1,27G  93,2G    23K  /zones/black

Paso 4.- Login y post-instalacion

El siguiente paso es arrancar la zona, que hemos indicado que no arrancará de forma automática en el paso de configuración

zoneadm -z black boot

Para conectarnos a la zona, desde el sistema anfitrión, ejecutamos

zlogin -l root black

Una vez dentro tenemos que configurar el interface de red para poder tener acceso a la zona mediante ssh

Creamos el interface de red en la nueva Zona

ipadm create-if vniczone2

Y le asignamos IP, en este caso de forma dinámica

ipadm create-addr -T dhcp vniczone2/v1

Ahora tenemos que crear un usuario para poder conectarnos por ssh porque no hereda los usuarios que haya creados en el sistema anfitrión:

Editamos /etc/auto_master y comentamos la línea con “/home”.
Creamos manualmente el directorio /export/home/<user>  y cambiamos en /etc/auto_home para que contenga la siguiente línea
* localhost:/export/home/&

Por último creamos el usuario y le asignamos contraseña

useradd -m cat

passwd cat

Así nos podemos conectar desde el anfitrion a nuestra nueva zona:

starman@arin:~$ ssh cat@192.168.0.196
Password:
The Illumos Project     SunOS 5.11      illumos-72136b4 March 2017
cat@black:~$ uname -a
SunOS black 5.11 illumos-72136b4 i86pc i386 i86pc

 

En las próximas entregas, cuando logre hacerlo funcionar, veremos como exportar el display por ssh de la zona Black a la anfitriona y, sobre todo, como crear una zona Linux.

Usa software libre, también en internet

Mucho se sabe y se habla del software libre en ordenadores, móviles, tablets, etc, pero ¿y qué hay de los servicios de internet que son libres?

– Bueno, es que twitter es libre
– No, bonito, no. Twitter es propiedad de una compañía y si lo usas tienes que aceptar sus reglas.

Como decía Richard Stallman en una charla a la que acudí hace unos meses: “cuando un servicio es gratuito es porque el producto eres tú”. No voy a entrar en los detalles o noticias sobre el uso que compañías como Twitter, Google o Facebook hacen con la información que les proveen los usuarios; de momento solo voy a empezar a recopilar, y más tarde actualizar, una lista de servicios libres que sustituyen a los más comunes y más utilizados y pondré alguna pequeña reseña, si se me ocurre algo que aportar. Así que aquí empezamos con nuestra lista:

Servicios* basados en principios libres en internet (versión 0.1)

* y a qué servicios no libres pueden sustituir

Correo electrónico

¿Buscando un sustituto de GMail libre y gratuito. Aquí tienes unas opciones. Eso si, ten en cuenta que no te darán el mismo espacio de almacenamiento e igual alguna vez te piden que les ayudes económicamente. Piensa que, a cambio, no se dedicarán a leer tu correo para mostrarte publicidad basada en tus gustos 😉

logoOpenMailBox OpenMailBox es un servicio que además de correo da almacenamiento en la nube mediante OwnCloud, XMPP, calendario y agenda de contactos.

 

riseup-rainbow

Riseup es un veterano de los servicios libres. Está especialmente orientado a personas que militan en colectivos sociales y libertarios (de ahí el logo, que no es casual, vaya) y para registrarse hay que rellenar un formulario (en inglés) y esperar a que te aprueben o recibir códigos de invitación. Incluye además listas de correo, XMPP y desde hace poco VPN.

Almacenamiento

logo_owncloud OwnCloud es una herramienta indispensable en esta lista. A parte de que algunos servicios como el ya mencionado OpenMailBox lo tengan disponible, la ventaja de ownCloud, que veremos que se repite en muchos servicios, es que te lo puedes montar en tu ordenador de casa, en el servidor dedicado que tengas contratado en tu CPD favorito o en ese servidor ubicado en aquel otro país sin convenios de extradición con aquella modélica transición.

 

Chat

100px-XMPP_logo Jabber/XMPP es un protocolo de chat con muchos años a sus espaldas. Es un servicio federado (palabro que volveremos a ver más adelante y que viene a significar que puedes registrarte en cualquier servidor que use el protocolo y hablar con cualquier usuario de la red de servidores) de código abierto que, junto con el plugin OTR, se convierte en un servicio muy seguro. Hay infinidad de servidores en los que registrarte. La mayoría solo te piden un nombre de usuario y una contraseña. Puedes usar tu cuenta con el servicio de OpenMailBox, con el de RaiseUp, con SinGuasa… o montarte el servidor en tu máquina favorita y unirte a la red desde tu propio dominio.

 

Redes Sociales

Heckert_GNU_whiteGNU/Social es una red social de microbloging (como Twitter, vaya) federada. Hay, nuevamente, muchos servidores en los que te puedes dar de alta para empezar. Puedes seguir a cualquier usuario de la red, estén o no en el mismo servidor que tú. Y si quieres puedes seguir a mi cuenta en quitter.se.

 

 

 

diaspora-social-networkDiaspora* (si, con el asterisco) es una red social tipo Facebook. Como GNU/Social es federada y de código abierto

 

 

Buscador

duckduckgoDuck Duck Go es un buscador muy similar a Google cuando Google cumplía aquello de “don’t be evil”. Es solo eso, un buscador. No hay recomendaciones ni publicidad pagada o encubierta. Solo sirve para buscar y nada más. No guarda registros de que has buscado tú para mostrarte publicidad en las páginas por las que navegues.

 

Mapas

openStreetMapsOpenStreetMaps es un servicio de mapas on-line. Y es mucho más que un sistema de código abierto ya que los mismos mapas son editables por la comunidad, que es la que los ha trazado desde hace años. Si, no tiene bonitas fotos aéreas ni el StreetView o las tiendas que pagan por aparecer en él. A cambio contiene información de rutas ciclistas, la ubicación de centros sociales autogestionados o incluso de las fuentes de agua que hay en las calles.

Inferno OS emulado sobre un Linux de 64 bits

Si, no me he olvidado de este blog. Digamos que me había retirado de la informática recreativo-experimental por un tiempo, pero aquí estoy de vuelta.

Hoy vamos a hacer funcionar emulado sobre un Linux de 64 bits Inferno OS, el sistema operativo distribuido procedente de Plan9, el sistema operativo de los Laboratorios Bell que estaba llamado a sustituir a UNIX (seguramente le sustituya el año que Linux sea el sistema operativo de los escritorios 😉 😉

Al tema. Hay algo de documentación bastante completa pero con una carencia importante. Cogemos la documentación que hay en Setting of OS Inferno New Edition y añadimos solo un cambio y dos advertencias

Advertencia 1: esto tiene más dependencias que el copón. Desgraciadamente las he ido instalando a la carrera con YaST2 así que no tengo una lista de todas las que he necesitado. Las podrán ir instalando sobre la marcha según vaya petando la instalación. Se puede reiniciar a placer.

Advertencia 2: Tengan mucho ojo en el paso posterior al destareado del código. Es de IMPERIOSA necesidad hacer un pull y un update a la última versión del código

El cambios: Después de tener actualizado el código del repositorio de Mercurial y de estar en el último commit, antes si quieren de modificar el fichero mkconfig, deben modificar el fichero Linux/386/include/fpuctl.h según indica en este comentario:

--- a/Linux/386/include/fpuctl.h	Sat Jun 08 13:03:33 2013 +0000
+++ b/Linux/386/include/fpuctl.h	Sun Jun 30 02:16:23 2013 +0800
<at> <at> -6,12 +6,12 <at> <at>
 static void
 setfcr(ulong fcr)
 {
-	__asm__(	"xorb	$0x3f, %%al\n\t"
+	__asm__ volatile(	"xorb	$0x3f, %%al\n\t"
 	"pushw	%%ax\n\t"
 	"fwait\n\t"
 	"fldcw	(%%esp)\n\t"
 	"popw	%%ax\n\t"
-	: /* no output */
+	: "=a" (fcr)
 	: "al" (fcr)
 	);
 }

Solo después de haber modificado este fichero y de seguir el resto de instrucciones que he puesto antes a rajatabla conseguirán esto:

Inferno

encFS – Sistema de archivos cifrado mediante FUSE

En ocasiones no es necesario cifrar un disco duro completo de nuestro ordenador. Por el motivo que sea nos puede servir con cifrar únicamente una parte del mismo, menos que una partición lógica en sí mismo. En este caso nos puede ser útil utilizar encFS

encFS es un comando que recibe dos parámetros en la llamada desde línea de comandos: el directorio que vamos a mantener cifrado y el path en el que “montamos” nuestro directorio descifrado.

encfs ~/cifrado ~/Documentos/copiaSegura

Si hacemos un ls en ~/cifrado veremos solo ficheros con nombre cifrado, mientras que en nuestra copiaSegura podremos acceder a los ficheros en formato lectura escritura. Una vez queramos terminar y cifrar los nuevos cambios solo tendremos que ejecutar:

fusermount -u ~/Documentos/copiaSegura

 

Arduino – Sensor de luz

Este es mi primer programa con Arduino.
Básicamente es un sensor de luz que, en base a una calibración realizada los cinco primeros segundos de ejecución, enciende una serie de leds. A más luz, más leds encendidos.

El plano eléctrico es como el que se muestra en las imagenes. Como nota aclaratoria, las cuatro resistencias de los leds están puenteadas a tierra así como la resistencia del sensor de luz. En la misma pata del sensor en la que está la resistencia sale un cable que se une con el Analog Input 0 (A0)CAM00107 CAM00108

El código fuente es sencillo. Uso cuatro leds para indicar la cantidad de iluminación que recibe el sensor, siendo cuatro en el rango máximo y cero en el mínimo. La función “map” se encarga de asociar el rango entre las dos variables sensorLow y sensorHigh que indican el mínimo y el máximo de luz obtenidos en la calibración.

/*Sensor de luz

Ejemplo de un sensor de luz que enciende, en funcion
de la cantidad de luz que reciba, una serie de leds.

Poca luz, apaga todos los leds
mucha luz, enciende los cuatro

*/

/*
El sensor de luz va conectado a A0 ademas de llevar una resistencia
con ground. En la otra pata va a 5v
*/

const int ledPin1=12;
const int ledPin2=11;
const int ledPin3=10;
const int ledPin4=9;
int sensorValue = 0;
int sensorLow = 100;
int sensorHigh = 0;

void setup(){
//comenzamos la calibracion. Lo indicamos iluminando todos los leds
pinMode(ledPin1, OUTPUT);
digitalWrite(ledPin1, HIGH);
pinMode(ledPin2, OUTPUT);
digitalWrite(ledPin2, HIGH);
pinMode(ledPin3, OUTPUT);
digitalWrite(ledPin3, HIGH);
pinMode(ledPin4, OUTPUT);
digitalWrite(ledPin4, HIGH);

//calibramos durante 5 segundos
while (millis() < 5000) {
sensorValue=analogRead(A0);

if(sensorValue > sensorHigh) {
sensorHigh = sensorValue;
}

if(sensorValue < sensorLow) {
sensorLow = sensorValue;
}
} //fin del while

//apagamos las luces
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, LOW);
digitalWrite(ledPin3, LOW);
digitalWrite(ledPin4, LOW);
}

void loop() {
sensorValue = analogRead(A0);

int luces=map(sensorValue, sensorLow, sensorHigh, 0, 4);

switch (luces) {
case 0:
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, LOW);
digitalWrite(ledPin3, LOW);
digitalWrite(ledPin4, LOW);
break;
case 1:
digitalWrite(ledPin1, HIGH);
digitalWrite(ledPin2, LOW);
digitalWrite(ledPin3, LOW);
digitalWrite(ledPin4, LOW);
break;
case 2:
digitalWrite(ledPin1, HIGH);
digitalWrite(ledPin2, HIGH);
digitalWrite(ledPin3, LOW);
digitalWrite(ledPin4, LOW);
break;
case 3:
digitalWrite(ledPin1, HIGH);
digitalWrite(ledPin2, HIGH);
digitalWrite(ledPin3, HIGH);
digitalWrite(ledPin4, LOW);
break;
case 4:
digitalWrite(ledPin1, HIGH);
digitalWrite(ledPin2, HIGH);
digitalWrite(ledPin3, HIGH);
digitalWrite(ledPin4, HIGH);
break;
default:
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, HIGH);
digitalWrite(ledPin3, LOW);
digitalWrite(ledPin4, HIGH);
break;
} //fin del case

delay(10);
}

RoboMind – Robótica para niños y no tan niños

RoboMind es una aplicación con un sencillo lenguaje de programación orientado al aprendizaje y primeros pasos de niños en el mundillo de la programación.

Mediante un sencillo lenguaje que permite crear búcles, funciones y sentencias de control damos órdenes a un robot para que se mueva por un escenario predefinido. Podemos comprobar si a la derecha tenemos un obstáculo, una línea blanca o si hay vía libre; podemos girar, avanzar, pintar líneas en el suelo… seguir el camino de vuelta… todo pensado para hacer los pinitos en la programación de una forma visual y entretenida.

ejemplo de RoboMind

Y como muestra, aquí un código de ejemplo: el robot busca una baliza y va pintando por el suelo el camino seguido. Cuando la encuentra la coje y desanda el camino hasta el punto de partida.

#Funcion de “vuelta a casa”
procedure volver(){
# Me doy la vuelta, 180º
right()
right()

# y ahora vuelvo a casa desandando el camino
repeat{
if(frontIsBlack())
{
forward(1)
}
else if(rightIsBlack())
{
right()
forward(1)
}else if(leftIsBlack())
{
left()
forward(1)
}else
{
end
}
}
}

repeat{
# Bucle principal. Recorro el escenario buscando la baliza. Si la encuentro llamo a la funcion volver
#Pinto la ruta seguida (para volver despues)
paintBlack()

# Miro a la izquierda
if(leftIsBeacon())
{
left()
pickUp()
right()
stopPainting()
volver()
}
# Miro a la derecha
if(rightIsBeacon())
{
right()
pickUp()
left()
stopPainting()
volver()
}

# Miro al frente
if(frontIsBeacon())
{
pickUp()
stopPainting()
volver()
}

if(frontIsClear())
{
forward(1)
}
else
{
right()
}
}

Primeros pasos en busca de la seguridad en internet

Esto pretende ser solo un ligero manual de cómo lograr cierta seguridad “personal” a la hora de usar internet. No pretende ser un doctorado ni tampoco creo que llegue a ser un tratado lo suficientemente bueno y profundo como para que llegue a ser “obra de referencia”. Digamos que van a ser unas notas personales que dejo aquí para general conocimiento.

Hoy: cifrado de datos

Aún a pesar de que las comunicaciones mediante correo electrónico, desde PC o desde móvil, estén bajo el protocolo ssh siempre nos puede venir bien conocer un poco más sobre encriptado GnuPG que nos de un extra de seguridad y confidencialidad a nuestras comunicaciones.

GnuPG es una herramienta de código abierto que permite administrar un sistema de claves públicas y privadas para la correcta encriptación de información: desde un correo electrónico a un fichero de texto, una imagen o un fichero comprimido de cuatro gigas con los planes para dominar el mundo…

Este manual se va a centrar, de momento, en dos plataformas: Fedora (GNU/Linux) y Android. He utilizado el siguiente manual, GnuPG básico, como guía para mis notas y experimentos. Vamos a partir del siguiente experimento básico: voy a crear un juego de llave privada y pública en Android y otro en Fedora, voy a compartir las llaves públicas de uno en el otro y así podré generarme un texto encriptado en una de las plataformas, enviármelo a mi correo de gmail y desencriptarlo en la otra plataforma.

Paso 1: GnuPG en Fedora

(nota: estos pasos son comunes para todos los sistemas GNU/Linux y otros Sistemas Operativos. Solo cambia el modo de instalar GnuPG en su máquina)

Instalamos GnuPG (como root, claro)

[root@arin ~]# yum install gnupg

El primer paso es crear la llave pública eligiendo como tipo de clave DSA y Elgamal:

[starman@arin ~]$ gpg –gen-key
gpg (GnuPG) 1.4.12; Copyright (C) 2012 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.

gpg: directorio `/home/starman/.gnupg’ creado
gpg: creado un nuevo fichero de configuración `/home/starman/.gnupg/gpg.conf’
gpg: AVISO: las opciones en `/home/starman/.gnupg/gpg.conf’ no están aún activas en esta ejecución
gpg: anillo `/home/starman/.gnupg/secring.gpg’ creado
gpg: anillo `/home/starman/.gnupg/pubring.gpg’ creado
Por favor seleccione tipo de clave deseado:
(1) RSA and RSA (default)
(2) DSA and Elgamal
(3) DSA (sólo firmar)
(4) RSA (sólo firmar)
Su elección: 1

Nos pedirá que especifiquemos la validez de la clave. La podemos poner sin fecha de caducidad o con la que mejor nos venga:

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
<n>  = la clave caduca en n días
<n>w = la clave caduca en n semanas
<n>m = la clave caduca en n meses
<n>y = la clave caduca en n años
¿Validez de la clave (0)?

Luego introducimos información como Nombre, Apellidos y correo electrónico (se puede mentir 😉 y validamos la información introducida:

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) <heinrichh@duesseldorf.de>”

Nombre y apellidos: Starman From Sirio
Dirección de correo electrónico: starman@fromsirio.si
Comentario: Starman
Ha seleccionado este ID de usuario:
“Starman From Sirio (Starman) <starman@fromsirio.si>”

¿Cambia (N)ombre, (C)omentario, (D)irección o (V)ale/(S)alir? V

y por último ponemos una contraseña para la llave. Ten en cuenta que si la contraseña es corta hará que tus llaves sean menos seguras. Es mucho mejor una contraseña de 20 caracteres, aunque sea una frase sin espacios, que una con muchos símbolos especiales pero demasiado corta. (Por ejemplo es mejor “labellaygraciosamozamarchosealabarlaropa” que “S0yG33K$0#~”) Mientras se genera la llave es necesario mover el ratón insistentemente para generar números aleatorios y así se lo indicará por pantalla

Necesita una frase contraseña para proteger su clave secreta.

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.

No hay suficientes bytes aleatorios disponibles. Por favor, haga algún
otro trabajo para que el sistema pueda recolectar más entropía
(se necesitan 284 bytes más).
………….+++++
.+++++
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: /home/starman/.gnupg/trustdb.gpg: se ha creado base de datos de confianza
gpg: clave 72AD9D0A 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:   1  firmada:   0  confianza: 0-, 0q, 0n, 0m, 0f, 1u
pub   2048R/72AD9D0A 2012-02-11
Huella de clave = 5F55 5D87 0769 80F0 1FDE  E47B 4EA6 551D 72AD 9D0A
uid                  Starman From Sirio (Starman) <starman@fromsirio.si>
sub   2048R/6E1EF611 2012-02-11

Ahora ya podremos consultar la clave generada mediante

gpg –list-keys
/home/starman/.gnupg/pubring.gpg
——————————–
pub   2048R/72AD9D0A 2012-02-11
uid                  Starman From Sirio (Starman) <starman@fromsirio.si>
sub   2048R/6E1EF611 2012-02-11

Y ver las claves privadas disponibles

[starman@arin ~]$ gpg –list-secret-keys
/home/starman/.gnupg/secring.gpg
——————————–
sec 2048R/72AD9D0A 2012-02-11
uid Starman From Sirio (Starman)
ssb 2048R/6E1EF611 2012-02-11

Paso 2: GnuPG en Android

Existen varias aplicaciones que nos permiten usar encriptado en Android. Básicamente se trata de programas para la gestión de las claves que además posibilitan enviar mediante la cuenta de gmail configurada en el móvil aquello que hemos encriptado y desencriptar lo recibido. En mi caso estoy probando APG, que lo podéis encontrar en el Market. Si quieres un manual con capturas de pantalla en inglés lo tienen aquí.

La generación del par de claves en APG funciona correctamente, pero luego no se pueden utilizar en Fedora (ni probablemente en ningún otro sistema) para encriptar, así que es necesario generar el par de claves pública y privada que queramos usar en nuestro teléfono en el PC igual que hemos generado la anterior. Una vez generadas se exportan las dos claves (la pública y la privada) a sendos ficheros y las importamos con la aplicación de Android

Básicamente los pasos son los mismos:

Primero añadimos, pulsando a Menú, una cuenta de gmail (esto es opcional) que debemos tener configurada en el teléfono

Luego, de nuevo en Menú, dentro de Administrar llaves privadas, importamos la llave privada. Hacemos el mismo proceso para la llave pública.

Paso 3: Intercambiar las claves públicas

El siguiente paso es importar en Android la clave pública creada en Fedora y viceversa. Tenga en cuenta que si quiere usar un sistema de claves GnuPG entre, pongamos, 5 personas, deberá enviar cada una de estas personas su clave pública a las otras 5 para así poder intercambiar documentos entre todos.

En Fedora exportamos la clave pública

[starman@arin ~]$ gpg –list-keys
/home/starman/.gnupg/pubring.gpg
——————————–
pub   2048R/72AD9D0A 2012-02-11
uid                  Starman From Sirio (Starman) <starman@fromsirio.si>
sub   2048R/6E1EF611 2012-02-11

[starman@arin ~]$ gpg –armor –output starman.asc –export starman@fromsirio.si
[starman@arin ~]$ ls -l starman.asc
-rw-rw-r–. 1 starman starman 1744 feb 11 15:30 starman.asc

Ahora la enviamos al destinatario con el que la queremos compartir, en este caso al email del móvil, y la importamos mediante APG

En APG deberemos hacer el mismo proceso (perdón por no tener capturas de pantalla). Desde Menú -> Administrar Llaves públicas deberemos exportar la llave pública y pasarla al ordenador con Fedora.

[starman@arin ~]$ gpg –import pubexport.asc
gpg: clave 09C23AA4: clave pública “Frascuelo Pelaez (Frascuelo) <Frascuelo.Pelaez@gmail.com>” importada
gpg: Cantidad total procesada: 1
gpg:               importadas: 1
[starman@arin ~]$ gpg –list-keys
/home/starman/.gnupg/pubring.gpg
——————————–
pub   2048R/72AD9D0A 2012-02-11
uid                  Starman From Sirio (Starman) <starman@fromsirio.si>
sub   2048R/6E1EF611 2012-02-11

pub   1024D/09C23AA4 2012-02-11
uid                  Frascuelo Pelaez (Frascuelo) <Frascuelo.Pelaez@gmail.com>

Y ya podremos empezar a compartir información cifrada entre las dos máquinas. Por ejemplo, creamos un fichero en Fedora y lo encriptamos:

[starman@arin ~]$ echo “Esto si que es una prueba de encriptado” > original.txt
[starman@arin ~]$ gpg –armor –recipient Frascuelo.Pelaez@gmail.com –encrypt original.txt
[starman@arin ~]$ cat original.txt.asc
—–BEGIN PGP MESSAGE—–
Version: GnuPG v1.4.12 (GNU/Linux)

hQEMA6HObxJ4MetNAQf/ayB7v1SJ4gwVWtuUAzolUjLnlAWU4Uu6unRKArp16/M3
wjzg2nxamteLPWVZEz+rj0TqpRLnvTDee0/FKOa89UEX/b+SevJ18rvV2lhLdAc7
8xOoqcArczYfHrmUTJCz1wIeickT8X//6CemcLOdpHizFKjn7gHtY5iwf8wP02ww
mgI38Daxe1zZSc1IWDMVB236bEudf7FDDwVIHMvEwcjRaklIWPN/qBWn+5Yoh2gv
DIhXUE9J1JiSA6UMbV+NuVuuxMGtkeSYIyVL6BYuR8SeiiKE5AoCQubFh5nQHim5
H3qnVU/3/Tr7Z5C49JRaaaeSUmC5RD8MmAomfSKjZtJuATMTT+7MDEoantoIkfm6
hVqLK4P4fY7mUDaAYf2TCrwbWWsJMy5A0vHuJxLO4xPMns4Yqlixeh5cv8ZUSIfH
4v1SPx/iLATX/6wAqgZXPEiZ0X4UkHK2ZIaSC4OAAHhQ2QQWOo65K7Lem8Cj3iw=
=t4uI
—–END PGP MESSAGE—–

Nos mandamos el fichero al móvil y una vez descargado nos dará la opción de abrirlo y descifrarlo con APG. Nos pedirá la “contraseña” de la llave privada que tenemos en el teléfono y nos lo descifrará correctamente.

Para hacer el paso contrario en el móvil es básicamente lo mismo. Ciframos el contenido en el móvil indicando el identificador de la llave pública del destinatario o destinatarios y para desencriptarlo en el PC tendremos que introducir la contraseña.

[starman@arin ~]$ gpg –decrypt original.txt.asc

Necesita una frase contraseña para desbloquear la clave secreta
del usuario: “Starman From Sirio (Starman) <starman@fromsirio.si>”
clave RSA de 2048 bits, ID 6E1EF611, creada el 2012-02-11(ID de clave primaria 72AD9D0A)

gpg: cifrado con clave RSA de 2048 bits, ID 6E1EF611, creada el 2012-02-11
“Starman From Sirio (Starman) <starman@fromsirio.si>”
Esto si que es una prueba de encriptado… de vuelta

Todo por la seguridad