Diferencias para "basededatos/postgresql/encriptaciongpg"

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 PGP 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: "PGPCRYPTO - 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 > 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

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

• 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 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