CARRERA: FECHA:27/1/2018

Ingeniería de Sistemas

ESTUDIANTE: Daniel Amay – ASIGNATURA: GRUPO:

Wilmer Camas – Jonathan Base de Datos II 1
Paladines –Edison Huiñaizaca

DOCENTE:
Ing. Alvaro Mejia

TEMA: Métodos para encriptar y desencriptar datos en Oracle 12 c Release 1, Mysql

5.7, Postgres 10 en Ubuntu 16.04

Encriptar y Desencriptar en Oracle 12 C Release 1

DBMS_CRYPTO en Oracle 12 c:
DBMS_CRYPTO proporciona una interfaz para cifrar y descifrar datos almacenados, y se
puede usar junto con programas PL / SQL que ejecutan comunicaciones de red.
Proporciona soporte para varios algoritmos de cifrado y hash estándar de la industria,
incluido el algoritmo de encriptación Advanced Encryption Standard (AES). AES ha
sido aprobado por el Instituto Nacional de Estándares y Tecnología (NIST) para
reemplazar el Estándar de Encriptación de Datos (DES).

DBMS_OBFUSCATION_TOOLKIT: está en desuso, ya que DBMS_CRYPTO está destinado a

reemplazar DBMS_OBFUSCATION_TOOLKIT, proporcionando una mayor facilidad de uso y
soporte para una gama de algoritmos para acomodar sistemas nuevos y existentes.

Paso 1: Conectarse al usuario system en Oracle

Paso 2:se debe crear un usuario al que lo llamamos “usr_p9”:

create user usr_p9 identified by cuenca;

Salida:
User USR_P9 creado

Paso 3: en el usuario creado anteriormente se debe crear una tabla de parámetros, en

donde almacenarán las llaves para la encriptación y desencriptación.

CREATE TABLE USR_P9. P9_PARAMETER

(
ID_PARAMETER NUMBER(4) NOT NULL,
PARAMETER_NAME VARCHAR2(10 BYTE) NOT NULL,
PARAMETER VARCHAR2(500 BYTE) NOT NULL
);

Paso 4: Insertar una llave de encriptación (inventada):

insert into USR_P9.P9_PARAMETER(ID_PARAMETER, PARAMETER_NAME, PARAMETER)

Values(1, 'KEY_CRYPT', 'a5b7c9d0a5b7c9d0a5b7c9d0a5b7c9d0a5b7c9d
0a5b7c9d0a5b7c9d0a5b7c9d0')

Paso 5: se debe habilitar los permisos de EXECUTE sobre DBMS_CRYPTO, de lo contrario

no correrá el procedimiento almacenado: Entramos a la base como SYS as SYSDBA.
Ejecutamos el comando:
grant execute on dbms_crypto to PUBLIC;

oracle@ubuntu-VirtualBox:/home/ubuntu$ sqlplus / as sysdba

SQL*Plus: Release 12.1.0.2.0 Production on Fri Jan 26 15:35:20 2018

Copyright (c) 1982, 2014, Oracle. All rights reserved.

Connected to:
Oracle Database 12c Enterprise Edition Release 12.1.0.2.0 - 64bit Production
With the Partitioning, OLAP, Advanced Analytics and Real Application Testing
options

SQL> grant execute on dbms_crypto to PUBLIC;

Grant succeeded.

Paso 6: Una vez que tenemos permisos de ejecución, crearemos la lógica de encriptación
y desencriptación. Conectados con el usuario “usr_p9” corremos los packages:
ADM_UTIL_spec.sql y ADM_UTIL_body.sql.

ADM_UTIL_spec.sql

CREATE OR REPLACE PACKAGE USR_P9.P9_UTIL AS

FUNCTION encryptor
(
input_string IN VARCHAR2
) RETURN RAW;

FUNCTION decryptor
(
INPUT_STRING IN VARCHAR2
)
RETURN VARCHAR2;

END;

Salida:

Package P9_UTIL compilado

ADM_UTIL_body.sql

CREATE OR REPLACE PACKAGE BODY USR_P9.P9_UTIL

IS
SQLERRMSG VARCHAR2(255);
SQLERRCDE NUMBER;
-----
-- Defined Encryption Methods:
-- DES_CBC_NONE: Data Encryption Standard Block Cipher, Cipher Block '
-- chaining, no padding
-- SH1_ECB_ZERO: Secure Hash Algorithm, Electronic Codebook Cipher
-- chaining, pad with zeroes
-----
DES_CBC_NONE CONSTANT PLS_INTEGER := DBMS_CRYPTO.ENCRYPT_DES +
DBMS_CRYPTO.CHAIN_CBC + DBMS_CRYPTO.PAD_NONE;
SH1_ECB_ZERO CONSTANT PLS_INTEGER :=
DBMS_CRYPTO.HASH_SH1 + DBMS_CRYPTO.CHAIN_ECB + DBMS_CRYPTO.PAD_ZERO;
FUNCTION encryptor (
input_string IN VARCHAR2
) RETURN RAW
IS
-- Local variables
key_seed VARCHAR2(64);
converted_seed RAW(64);
converted_string RAW(64);
encrypted_string RAW(64);

BEGIN
SELECT parameter
INTO key_seed
FROM USR_P9.P9_PARAMETER
WHERE PARAMETER_NAME = 'KEY_CRYPT';

-- Convert incoming string and supplied seed to RAW datatype using the
-- new UTLI18N package to convert the string to the AL32UTF8 character
-- set
converted_string := UTL_I18N.STRING_TO_RAW(input_string, 'AL32UTF8');
converted_seed := UTL_I18N.STRING_TO_RAW(key_seed, 'AL32UTF8');

-- Encrypt the RAW value using the ENCRYPT function and the appropriate
-- encryption type
encrypted_string :=
DBMS_CRYPTO.ENCRYPT(
src => converted_string
,typ => SH1_ECB_ZERO
,key => converted_seed
,iv => NULL);
RETURN encrypted_string;
EXCEPTION
WHEN OTHERS THEN
SQLERRMSG := SQLERRM;
SQLERRCDE := SQLCODE;
RETURN NULL;
END encryptor;

FUNCTION decryptor (
input_string IN VARCHAR2 )
RETURN VARCHAR2
IS
-- Local variables c
onverted_string VARCHAR2(64);
key_seed VARCHAR2(64) ;
converted_seed RAW(64);
decrypted_string VARCHAR2(64);

BEGIN
SELECT parameter
INTO key_seed
FROM USR_P9.P9_PARAMETER
WHERE PARAMETER_NAME =
'KEY_CRYPT';
-- Convert incoming string and supplied seed to RAW datatype using the
-- new UTLI18N package to convert the string to the AL32UTF8 character
-- set
converted_string := UTL_I18N.STRING_TO_RAW(input_string, 'AL32UTF8');
converted_seed := UTL_I18N.STRING_TO_RAW(key_seed, 'AL32UTF8');

-- Encrypt the RAW value using the ENCRYPT function and the appropriate
-- encryption type
decrypted_string :=
DBMS_CRYPTO.DECRYPT(
src => input_string ,
typ => SH1_ECB_ZERO ,
key => converted_seed ,
iv => NULL);
-- Convert incoming string to RAW datatype, using the UTLI18N package
-- to convert the string to the AL32UTF8 character set
converted_string := UTL_I18N.RAW_TO_CHAR(decrypted_string, 'AL32UTF8'); RETURN
converted_string; EXCEPTION WHEN OTHERS THEN SQLERRMSG := SQLERRM; SQLERRCDE :=
SQLCODE; RETURN NULL; END decryptor; END;

Salida:

Package Body P9_UTIL compilado

Paso 7: ejecutar el siguiente Bloque anónimo para probar su funcionalidad en el

usuario de Oracle “USR_P9”

Primero se debe habilitar el paquete DBMS_OUTPUT para ver los resultados. Con el
comando: set serveroutput on

Segunda Forma para encriptar y desencriptar datos en oracle 12 c Release 1

CREATE OR REPLACE PACKAGE toolkit AS

FUNCTION encrypt (p_text IN VARCHAR2) RETURN RAW;
 FUNCTION decrypt (p_raw IN RAW) RETURN VARCHAR2;

END toolkit;

CREATE OR REPLACE PACKAGE BODY toolkit AS

g_key RAW(32767) := UTL_RAW.cast_to_raw('12345678');

g_pad_chr VARCHAR2(1) := '~';

PROCEDURE padstring (p_text IN OUT VARCHAR2);

-- --------------------------------------------------
FUNCTION encrypt (p_text IN VARCHAR2) RETURN RAW IS
-- --------------------------------------------------
l_text VARCHAR2(32767) := p_text;
l_encrypted RAW(32767);
BEGIN
padstring(l_text);
DBMS_OBFUSCATION_TOOLKIT.desencrypt(input =>
UTL_RAW.cast_to_raw(l_text),
key => g_key,
encrypted_data => l_encrypted);
RETURN l_encrypted;
END;

-- --------------------------------------------------
FUNCTION decrypt (p_raw IN RAW) RETURN VARCHAR2 IS
-- --------------------------------------------------
l_decrypted VARCHAR2(32767);
BEGIN
DBMS_OBFUSCATION_TOOLKIT.desdecrypt(input => p_raw,
key => g_key,
decrypted_data => l_decrypted);

RETURN RTrim(UTL_RAW.cast_to_varchar2(l_decrypted), g_pad_chr);

END;
-- --------------------------------------------------

-- --------------------------------------------------
PROCEDURE padstring (p_text IN OUT VARCHAR2) IS
-- --------------------------------------------------
l_units NUMBER;
BEGIN
IF LENGTH(p_text) MOD 8 > 0 THEN
l_units := TRUNC(LENGTH(p_text)/8) + 1;
p_text := RPAD(p_text, l_units * 8, g_pad_chr);
END IF;
END;
 -- --------------------------------------------------

END toolkit;

--FUNCIONAMIENTO
set serveroutput on

DECLARE
l_value VARCHAR2(16) := 'Daniel Amay';
l_raw RAW(16);
BEGIN
DBMS_OUTPUT.put_line('Texto: ' || l_value);
l_raw := toolkit.encrypt(l_value);
DBMS_OUTPUT.put_line('Texto_Encriptado: ' || l_raw);
DBMS_OUTPUT.put_line('Valor Original : ' || toolkit.decrypt(l_raw));
END;
Encriptación y Desencriptación en Postgres 10:

Para encriptar primero debemos habilitar la extensión pgcrypto corriendo la

siguiente línea.

Create extension pgcrypto;

Salida:

CREATE EXTENSION

Query returned successfully in 314 msec.

Crear una tabla que llamaremos Persona

CREATE TABLE personas(

per_id numeric (9),
per_nombre varchar(80)
);

Primera forma de encriptar y desencriptar

3DES :(TRIPLE DATA ENCRYPTION STANDARD)

Aplica el algoritmo 3 veces, la clave tiene una longitud de 128 bits. Si se cifra el
mismo bloque de datos dos veces con dos llaves diferentes, aumenta el tamaño de la
clave.

--insert
insert into public."personas" (per_id, per_nombre)
values (1, encrypt('Daniel Amay', 'llave', '3des')::text);

--SELECT NORMAL
SELECT * FROM personas

-el método encode nos permite descifrar la información

-el método decrypt permite hacer una conversión de datos a tipo bytea

select per_id, encode(decrypt(per_nombre::bytea, 'llave',

'3des'::text),'escape'::text) from personas;
Segunda Forma:

DES (DATA ENCRYPTION STANDARD)

El algoritmo DES usa una clave simétrica de 64 bits, los primeros 56 son empleados
en cifrado, y los 8 restantes se usa para la comprobación de errores durante el
proceso.

--segunda forma

--insert
insert into public."personas" (per_id, per_nombre)
values (2, encrypt('Wilmer Camas', 'llave', 'des')::text);

--select normal
SELECT * FROM personas where per_id=2;

select per_id,per_nombre as Dato_Encriptado, encode(decrypt(per_nombre::bytea,

'llave',
'des'::text),'escape'::text)
from personas
where per_id=2;
Tercera Forma:

--insert
insert into public."personas" (per_id, per_nombre)
values (3, encrypt('Edison Huinaizaca', 'llave', 'bf')::text);

select per_id,per_nombre AS dato_encriptado, encode(decrypt(per_nombre::bytea,

'llave',
'bf'::text),'escape'::text)
from personas
where per_id=3;
Encriptar y Desencriptar datos en MYSQL:

Primera forma para encriptar y desencriptar

Función AES_DECRYPT(), AES_ENCRYPT()

La Función AES_DESCRIPT () Y AES_ENCRIPT son funciones propias de mysql que permiten
implementar cifrado y descifrado de datos utilizando el algoritmo oficial AES
(Advanced Encryption Standard). El cual permite varias longitudes de clave. Esta
función implementa una longitud de clave de 128 bits, pero puede ampliarlas a 256
bits modificando la fuente. La longitud de la clave es una compensación entre el
rendimiento y la seguridad.

Primera forma usando (AES_ENCRYPT - AES_DECRYPT)

Crear la Tabla persona para probar los diferentes métodos para encriptar y
desencriptar datos.

CREATE TABLE Persona (

id BIGINT UNSIGNED AUTO_INCREMENT ,

nombre VARBINARY(100) ,

apellido VARBINARY(200) ,

PRIMARY KEY (id));

#-----primera forma de encriptación

INSERT into Persona(nombre, apellido)

VALUES (AES_ENCRYPT('Juan', 'clave'),AES_ENCRYPT('Perez', 'clave'));

Select sin usar AES_DECRYPT:

SELECT id,

CAST(nombre AS

CHAR(50)) Nombre,

CAST(apellido AS CHAR(50)) Apellido

FROM Persona

where id=1;

Resultado:

Select para desencriptar datos usando AES_DECRYPT:

SELECT id,
 CAST(AES_DECRYPT(nombre, 'clave') AS

CHAR(50)) Nombre,

CAST(AES_DECRYPT(apellido, 'clave') AS CHAR(50))Apellido

FROM Persona

where id=1;

Segunda Forma: usando (encode -decode)

Funcion encode: esta función convierte un dato en una cadena encriptada

Funcion decode: Esta función descripta la función decode la cual es una cadena de

texto

INSERT into Persona (nombre, apellido) VALUES (encode('Maria',

'clave'),encode('Campos', 'clave'));

Select sin decode:

SELECT id,
 CAST(nombre AS

CHAR(50)) nombre,

CAST(Apellido AS CHAR(50)) apellido

FROM Persona

WHERE id=2;

Resultado:

Select usando decode:

SELECT id,

CAST(decode(nombre, 'clave') AS

CHAR(50)) nombre,

CAST(decode(Apellido, 'clave') AS CHAR(50)) Apellido

FROM Persona

WHERE id=2;

Resultado:
Tercera Forma usando (des_encrypt):

Esta función encripta la cadena con la clave dada usando el algoritmo Triple-DES.

Para que de esta forma los datos puedan estar encriptados de una mejor manera.

INSERT into Persona (nombre, apellido)

VALUES (des_encrypt('Juan', 'clave'),des_encrypt('Armijos', 'clave'));

#--Select sin usar (des_encrypt)

SELECT id,

CAST(nombre AS

CHAR(50)) Nombre,

CAST(apellido AS CHAR(50)) apellido

FROM Persona

where id=3;
#---select para desencriptar usando (des_encrypt)

SELECT id,

CAST(des_decrypt(nombre, 'clave') AS

CHAR(50)) Nombre,

CAST(des_decrypt(apellido, 'clave') AS CHAR(50)) Apellido

FROM Persona

where id=3;
CONCLUSIONES
-Utilizar estos métodos de encriptación nos ayudan a proteger los datos de la base
de datos.
-Permite controlar el acceso a los usuarios mediante la encriptación.
-Para poder visualizar las funciones y procedimientos se debe ejecutar la linea :
set serveroutput
on;

Bibliografía:
mariiss15. (2012, nov 14). mariss15. Retrieved from mariis15:
https://mariiss15.wordpress.com/2012/11/14/algoritmos-de-encriptacion-simetrica-y-
asimetrica/
wilson, c. (2015). administarcion de base de datos con postgresSQL. In M. I. ing.
Mariuxi paola,
administarcion de base de datos con postgresSQL (p. 86). cuenca: UPS
(2017). Database PL/SQL Packages and Types Reference. 26/1/2018, de Oracle Sitio
web: https://docs.oracle.com/database/121/ARPLS/d_crypto.htm#ARPLS664
(2017). DBMS_OBFUSCATION_TOOLKIT. 26/1/2018, de Database PL/SQL Packages and Types
Reference Sitio web:
https://docs.oracle.com/cd/E11882_01/appdev.112/e40758/d_obtool.htm#ARPLS028