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

           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)

           RSA keys may be between 1024 and 4096 bits long.
           What keysize do you want? (4096)

           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)

           Is this correct (y/n)? (y)

           GnuPG need construct a user ID to identify your key

           Real name: <Nombre> <Apellido>
           Email address: correo@coreo.cl
           Comment: "PGPCRYPTO - Test"

           Change (N)ame, (E)mail o (C)omment or (O)kay/(Q)uit? (o)

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 > private.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 private.keys

PGPCRYPTO

Intalación de paquete contrib de postgresql. Este contiene como uno de sus módulos PGPCRYPTO. Recordar entrar con atelación a usuario root: 

# apt-get install postgresql-contrib

Para listar o ver el contenido del modulo PGPCRYPTO: 

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 PGPCRYPTO, para esto debe ingresar la siguiente linea de comandos: 

testCrypto=# CREATE EXTENSION pgcrypto;

Luego se debe crear una "instancia" del lenguaje a utilizar para la creación de las funciones: 

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): 

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;

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: 

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;

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 1

Consultar 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