Tabla de Contenidos
Creación de llaves públicas y privadas
Instalar gpg2. Desde usuario root debe agregar la siguiente linea de comando:
# apt-get install gnupg2
Creación de claves bajo el uso de gpg2. Este comando genera un par de claves que consiste en una clave pública y privada:
gpg2 --gen-key
A continuación viene una serie de preguntas para la creación exitosa de las claves antes mencionadas. Las opciones (las primeras) por defecto generalmente son las utilizadas.
Se pide seleccionar un tipo para las claves a crear:
Please select what kind of key you want: (1) RSA and RSA (default) (2) DSA and Elgamal (3) DSA (sign only) (4) RSA (sign only) Your selection? (1)
Elegir el tamaño de la clave (Entre mayor la cantidad de bits mejor):
RSA keys may be between 1024 and 4096 bits long. What keysize do you want? (4096)
Elegir cuando la clave expirará:
Please specify how long the key should be valid. 0 = key does not expire <n> = key expires in n days <n>w = key expires in n weeks <n>m = key expires in n months <n>y = key expires in n years Key is valid for? (0)
Antes de que el programa gpg pida la información de la firma, aparecerá el siguiente mensaje:
Is this correct (y/n)? (y)
Al agregar la opción "y" se terminará el proceso, en donde si todo anda bien se mostrará en cosola el siguiente texto:
GnuPG need construct a user ID to identify your key
En el siguiente paso GPG pedirá al usuario toda la información correspondiente para la firma:
- Recuerde que este proceso se trata de identificarlo. Por esta razón, incluya su nombre real, no use un alias ya que puede confundir su indentidad.
- Ingrese su correo electrónico real a su clave GPG, ya que, el programa utiliza esta información como identificador.
- Utilice el espacio de comentario para incluir alias u otra información.
Real name: <Nombre> <Apellido> Email address: correo@coreo.cl Comment: "PGCRYPTO - Test"
Cuando aparezca la confirmación, ingrese la letra O para continuar si todo está correcto, o use las otras opciones para arreglar cualquier problema.
Change (N)ame, (E)mail o (C)omment or (O)kay/(Q)uit? (o)
Al terminar esta tarea, usted deberá ingresar una frase para su clave secreta. El programa gpg le pedirá que introduzca su contraseña dos veces para asegurarse de que usted no haya cometido algún error al escribirlo. Por último, gpg genera datos aleatorios para hacer su clave tan única como sea posible. Mueva el puntero del ratón, escriba con el teclado o realice otras tareas en el sistema durante este paso, esto le entregará mayor aleatoriedad al proceso. (Puede tardar unos minutos). Proceso terminado.
Listar las claves creadas con GPG
gpg2 --list-key
Exportar clave pública creada a un archivo de texto plano:
gpg2 -a --export correo@correo.cl > public.key
Exportar clave prívada creada a un archivo de texto plano:
gpg2 -a --export-secret-keys correo@correo.cl > secret.key
Se le otorgan permisos de escritura y lectura a la llave privada generada. Además es importante tener en cuenta que es necesario conocer exactamente esta llave, ya que, sin ella no se pondrán desencriptar los archivos
chmod 440 secret.key
Pgcrypto
Intalación de paquete contrib de postgresql. Este contiene como uno de sus módulos PGCRYPTO. Recordar entrar con antelación a usuario root:
# apt-get install postgresql-contrib
Para listar o ver el contenido del modulo PGCRYPTO:
ls /usr/share/postgresql/9.3/extension/pgcrypto--1.0.sql
o
vim /usr/share/postgresql/9.3/extension/pgcrypto--1.0.sql
Implementación
Primero se debe crear la extensión de PGCRYPTO, para esto debe ingresar la siguiente linea de comandos (recuerde entrar previamente a la base de datos en donde desea realizar todo el procedimiento, en este este ejemplo nuestra base de datos tendrá el nombre testCrypto):
testCrypto=# CREATE EXTENSION pgcrypto;
Luego se debe crear una instancia del lenguaje a utilizar para la creación de las funciones necesarias:
testCrypto=# CREATE LANGUAGE plpythonu;
Una vez finalizado los 2 pasos anteriores se deben agregar todas las funciones que vienen con el paquete postgresql-contrib
psql db_name < /usr/share/postgresql/9.3/extension/pgcrypto--1.0.sql
Creación de funciones
El siguiente paso es la creación de las siguientes funciones, cuya utilidad es ir a buscar las llaves publicas y privadas que se crearon, esto con el fin de encriptar y desencriptar la información (Recuerde entregar los path correctos de la ubicación de las llaves según corresponda):
Llave Pública (para encriptar datos)
create or replace function get_my_public_key() returns text as $$
return open('/path/to/public.key').read()
$$
language plpythonu;
revoke all on function get_my_public_key() from public;
Llave Privada (para desencriptar datos)
create or replace function get_my_secret_key() returns text as $$
return open('/path/to/secret.key').read()
$$
language plpythonu;
revoke all on function get_my_secret_key() from public;Una vez ya creadas las funcione encargadas de ir en la búsquedas de las llaves, se debe proceder a la creación de las funciones para ya realizar de lleno la encriptación y desencriptación de los datos:
Encriptar
CREATE OR REPLACE FUNCTION public.encrypt_using_my_public_key(
IN cleartext text,
OUT ciphertext bytea)
RETURNS bytea AS
$BODY$
DECLARE
pubkey_bin bytea;
BEGIN
-- text version of public key needs to be passed through function dearmor() to get to raw key
pubkey_bin := dearmor(get_my_public_key());
ciphertext := pgp_pub_encrypt(cleartext, pubkey_bin);
END;
$BODY$
LANGUAGE plpgsql VOLATILE SECURITY DEFINER
COST 100;
ALTER FUNCTION public.encrypt_using_my_public_key(text)
OWNER TO <user>;
GRANT EXECUTE ON FUNCTION public.encrypt_using_my_public_key(text) TO <user>;
REVOKE ALL ON FUNCTION public.encrypt_using_my_public_key(text) FROM public;
Desencriptar
CREATE OR REPLACE FUNCTION public.decrypt_using_my_secret_key(
IN ciphertext bytea,
OUT cleartext text)
RETURNS text AS
$BODY$
DECLARE
secret_key_bin bytea;
secret_phase text;
BEGIN
-- text version of secret key needs to be passed through function dearmor() to get to raw binary key
secret_key_bin := dearmor(get_my_secret_key());
secret_phase = 'YOUR SECRET PASSWORD KEY';
cleartext := pgp_pub_decrypt(ciphertext, secret_key_bin, secret_phase);
END;
$BODY$
LANGUAGE plpgsql VOLATILE SECURITY DEFINER
COST 100;
ALTER FUNCTION public.decrypt_using_my_secret_key(bytea)
OWNER TO <user>;
GRANT EXECUTE ON FUNCTION public.decrypt_using_my_secret_key(bytea) TO <user>;
REVOKE ALL ON FUNCTION public.decrypt_using_my_secret_key(bytea) FROM public;
Pruebas de funcionamiento
Crea una tabla en la base de datos:
CREATE TABLE notes ( id integer, note bytea, description text, CONSTRAINT pk_notes PRIMARY KEY (id) )
Verificar creación exitosa de la tabla en la base de datos:
testCrypto=# \d
List of relations
Schema | Name | Type | Owner
--------+-------+-------+---------
public | notes | table | <user>
(1 row)
testCrypto=# \d notes
Table "public.notes"
Column | Type | Modifiers
-------------+---------+-----------
id | integer | not null
note | bytea |
description | text |
Indexes:
"pk_notes" PRIMARY KEY, btree (id)* Recordar que sólo estamos encriptando el campo note de la tabla notes, además esto se puede ver en la tabla, ya que, es el único con el tipo de dato BYTEA.
Agregar nuevo dato encriptado a la tabla creada:
testCrypto=# insert into notes values (1, encrypt_using_my_public_key('test'),'test');
INSERT 0 1Consultar valor del dato encriptado en texto legible:
testCrypto=# select id, decrypt_using_my_secret_key(note) as note, description from notes; id | note | description ----+------+------------- 2 | test | test
Extras
Para eliminar una clave de GPG primero se debe eliminar la clave secreta, para esta acción se debe digitar en consola:
gpg --delete-secret-key <idkey>
Luego se debe eliminar la clave pública
gpg --delete-key <idkey>
Finalmente puede hacer nuevamente un listado de las claves para verificar que se realizó correctamente este proceso.