Aplicación software para el desarrollo de tareas criptográficas

ESCUELA TÉCNICA SUPERIOR DE
INGENIERÍA DE TELECOMUNICACIÓN

UNIVERSIDAD DE MÁLAGA

PROYECTO FIN DE CARRERA

APLICACIÓN SOFTWARE PARA EL DESARROLLO DE
TAREAS CRIPTOGRÁFICAS


MÁLAGA, 2008

GÉNESIS GARCÍA MORILLA

ESCUELA TÉCNICA SUPERIOR DE

Titulación: Ingeniería Telecomunicación

Reunido el tribunal examinador en el día de la fecha, constituido por:
D./Dª.__________________________________________________________
D./Dª.__________________________________________________________
D./Dª.__________________________________________________________
Para juzgar el Proyecto Fin de Carrera titulado:

APLICACIÓN SOFTWARE PARA EL DESARROLLO DE
Del alumno D. Génesis García Morilla
Dirigido por Dª. Mª Carmen Clemente Medina

ACORDÓ POR

______________________________________ OTORGAR LA

CALIFICACIÓN DE _______________________________________________

Y, para que conste, se extiende firmada por los componentes del tribunal, la
presente diligencia

Málaga, a ______ de __________________ de 2008

El/La Presidente/a

El/La Vocal

El/La Secretario/a

Fdo.: _________________ Fdo.: _________________ Fdo.: _________________

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA
DE TELECOMUNICACIÓN

APLICACIÓN SOFWARE PARA EL DESARROLLO DE
REALIZADO POR:
Génesis García Morilla
DIRIGIDO POR:
Mª Carmen Clemente Medina

DEPARTAMENTO DE: Ingeniería de Comunicaciones
TITULACIÓN:

Ingeniería Técnica de Telecomunicación
Sistemas de Telecomunicación

PALABRAS CLAVES:

Criptografía, RSA, DES, TDES, RSA Digital, Software,
Lenguaje C++, Gráficos Qt, Precisión Aritmética GMP.

RESUMEN:

Aplicación software para la realización de tareas
criptográficas a través de algoritmos como el RSA de
clave pública y los algoritmos de clave privada DES y
TDES, a su vez también permite el uso del protocolo
RSA Digital. Construida utilizando C++ como lenguaje
de programación, Qt como librería para la interfaz
gráfica y GMP como librería para la aritmética de
múltiple precisión.

Málaga, Febrero de 2008

A mis padres Antonio y Paqui,
Y a mis hermanas Lidia y Anay.

Índice
PREFACIO
CAPÍTULO 1 - Introducción…………………………………..1
1.1.- Objetivos…………………………………………….4
1.2.- Requisitos……………………………………………4
1.3.- Fases del trabajo……………………………………...5
1.4.- Configuración del sistema…………………………..27
1.4.1.- Linux………………………………………………………..28
1.4.2.- Windows XP………………………………………………..28
1.4.3.- Mac OS……………………………………………………..30

1.5.- Relación entre clases………………………………...30

CAPÍTULO 2 - Algoritmos Criptográficos Desarrollados…..35
2.1.- RSA………………………………………………….37
2.1.1.- Introducción………………………………………………..37
2.1.2.- Generación de claves………………………………………38
2.1.3.- Cifrado……………………………………………………..41
2.1.4.- Descifrado………………………………………………….42
2.1.5.- Conclusiones……………………………………………….44

2.2.- DES………………………………………………….46
2.2.1.- Introducción………………………………………………..46
2.2.2.- Generación de claves………………………………………46
2.2.3.- Cifrado……………………………………………………..48
2.2.4.- Descifrado………………………………………………….53
2.2.5.- Conclusiones……………………………………………….53

2.3.- Triple DES…………………………………………..57
2.3.1.- Introducción………………………………………………..57
2.3.2.- Cifrado y descifrado………………………………………..57
2.3.3.- Conclusiones……………………………………………….58

2.4.- RSA Digital…………………………………………60
2.4.1.- Introducción………………………………………………..60
2.4.2.- Cifrado y descifrado………………………………………..61
2.4.3.- Firmado digital……………………………………………..61
2.4.4.- Conclusiones……………………………………………….62
I

2.5.- Gestión de Claves de los Algoritmos Desarrollados..63
2.5.1.- Introducción………………………………………………..63
2.5.2.- Gestión de claves en RSA…………………………………63
2.5.3.- Gestión de claves en DES y TDES………………………..66
2.5.3.- Gestión de claves en RSA Digital…………………………66

CAPÍTULO 3 - Descripción de la Aplicación………………...69
3.1.- Introducción…………………………………………71
3.2.- Pantalla Principal……………………………………71
3.3.- Menú Algoritmo Criptográfico……………………...75
3.3.1- Menú RSA………………………………………………….76
3.3.2- Menú DES y TDES………………………………...………83
3.3.3- Menú RSA Digital………………………………………….84

CAPÍTULO 4 - Conclusiones, líneas futuras y limitaciones...89
4.1.- Conclusiones………………………………………...91
4.2.- Líneas futuras………………………………………..92
4.3.- Limitaciones…………………………………………95

APÉNDICE A - Manual de Usuario………………………….97
A.1.- Pasos comunes para todos los algoritmos…………..99
A.1.- Usando RSA……………………………………….102
A.2.- Usando DES y TDES……………………………...104
A.3.- Usando RSA Digital………………………………105

APÉNDICE B - Conceptos básicos sobre Criptografía…….109
B.1.- Historia…………………………………………….111
B.2.- Criptología…………………………………………113
B.3.- Terminología………………………………………113
B.4.- Canal de información……………………………...114
B.5.- Criptosistemas……………………………………..115
B.6.- Algoritmo criptográfico…………………………...116
B.7.- Clave criptográfica………………………………...116
B.8.- Longitud de clave………………………………….117
B.9.- Base Matemática RSA…………………………….117
B.10.- Base Matemática DES……………………………120

APÉNDICE C - Criptosistemas.……………………………..123
C.1.- Clasificación……………………………………….125
II

C.2.- Criptosistemas Simétricos…………………………126
C.3.- Criptosistemas Asimétricos………………………..129

Índices extraordinarios………………………………………...135
I.1.- Cuadros de Código…………………………………137
I.2.- Figuras……………………………………………...138
I.3.- Tablas………………………………………………141
I.4.- Ecuaciones………………………………………….141

BIBLIOGRAFÍA - REFERENCIA….………………………...143
B.R.1.- Criptografía……………………………………...145
B.R.2.- Programación……………………………………148
B.R.3.- Matemáticas……………………………………..150
B.R.4.- Software similar…………………………………150
B.R.5.- Diseño…………………………………………...150

III

PREFACIO
Este proyecto fue elegido a razón del interés propio sobre la realización
software y la curiosidad aportada por el mundo de la criptografía. Se le ofrece la
posibilidad al lector de adentrarse en ambos campos, con los siguientes capítulos
que comprenden la documentación propia del software criptográfico realizado. A
su vez, existe una documentación extra formada por una serie de apéndices para
complementar los capítulos, unos índices extraordinarios y la bibliografíareferencia consultada al final del libro.
En el Capítulo 1, se ofrece una breve introducción comentando cuando y
por qué se usa la criptografía, los sistemas más adecuados según el uso y los
inconvenientes de la criptografía. Se exponen cuales fueron los objetivos y
requisitos para la realización del software. Se detallan las fases de trabajo, así
como la configuración del sistema necesaria para ello. Además se indica
esquemáticamente las relaciones existentes entre las clases obtenidas al final del
trabajo.
En el Capítulo 2, se explican todos y cada uno de los algoritmos
criptográficos realizados, a través de una introducción al criptosistema, su
generación de claves, cifrado y descifrado. Se detallan las partes más relevantes
del código implementado de estos, se indican sus ventajas e inconvenientes, y
uso actual que acarrean. El final de este capítulo hace referencia a las
implementaciones para la gestión de claves de cada uno de los algoritmos
desarrollados.
En el Capítulo 3, se describe la aplicación software haciendo uso de los
diferentes menús que la componen. En principio se presenta una visión general
de la aplicación, para luego ir adentrándose en las posibilidades criptográficas que
ofrece gracias a los menús característicos de cada criptosistema implementado.
En el Capítulo 4, se exponen las conclusiones del desarrollo de la
aplicación,
sus posibles mejoras y adaptaciones futuras, así como sus
limitaciones de uso.
En el Apéndice A, se encuentra el manual de usuario de la aplicación. Se
muestran los pasos comunes e independientes de la tarea criptográfica a realizar
y los pasos necesarios para el uso concreto de cada tarea, de forma que pueda
sacársele el máximo partido. Este apéndice complementa al capítulo 3.
En el Apéndice B, se presenta un breve resumen histórico de la criptografía
y los conceptos presupuestos necesarios de cara a este proyecto. Estos
conceptos son los referentes a terminología usada, algoritmo criptográfico, canal,
claves y bases matemáticas. Este apéndice complementa al capítulo 1 y 2, y se
recomienda su lectura en caso de déficit de conocimiento criptográfico básico del
lector.

En el Apéndice C, se introduce la clasificación de los criptosistemas junto
con sus bases y se listan muy brevemente los más importantes. Este apéndice
complementa al capítulo 1, 2, 4, y se recomienda su lectura.
En los Índices Extraordinarios, aparecen las listas con referencia de página
de cuadros de código, figuras, tablas y ecuaciones mostradas a lo largo del libro.
En la Bibliografía-Referencia, se indica toda la documentación sobre
criptografía, programación, matemáticas, aplicaciones similares a la realizada y
programas para el diseño, que se consultó en enlaces de Internet y libros, así
como libros extras para la profundización sobre temas criptográficos.
Junto a la este libro se obsequia un CD-ROM con el libro para su consulta
en formato pdf, el código fuente y el ejecutable del software realizado.

Proyecto Fin de Carrera

Capítulo 1: Introducción

CAPÍTULO 1 – Introducción.
La seguridad y protección de datos se han convertido en cuestiones de vital
importancia para las comunicaciones electrónicas. Desde navegar por Internet
hasta hacer la compra, requieren de criptosistemas y protocolos que oculten la
información, verifiquen quienes somos, con quien nos comunicamos y que canal
es seguro. Esta seguridad y protección es necesaria para la expansión y
desarrolló de la sociedad de la información, puesto que provee los medios para
que se realicen comunicaciones legales sin necesidad de la presencia física del
individuo y permiten guardar información deseada para acceso y uso exclusivo de
estos.
Las ramas al frente del uso de la criptografía son básicamente las formadas
por los sistemas simétricos y los asimétricos (véase Apéndice C). Los simétricos,
son aquellos algoritmos criptográficos que usan una clave para todo, motivo por el
cual se conocen también como sistemas de clave secreta. Estos algoritmos son
rápidos, hacen uso de recursos matemáticos básicos y fueron los primeros en
integrarse. Sin embargo, desde la aparición de los sistemas asimétricos están en
decadencia. Los asimétricos, son aquellos algoritmos criptográficos que usan una
clave pública para cifrar y otra privada para descifrar, motivo por el cual se
conocen también como sistemas de clave pública. Estos algoritmos son más
lentos, debido al uso de una base matemática compleja, y requieren mayores
recursos de procesado, pero añaden mayor seguridad y protección que los
sistemas simétricos. En principio, el uso de los asimétricos estaba muy limitado en
la década de los 70s y 80s, pero a medida que aumentaba la capacidad
computacional, iban suplantando en algunos ámbitos a los algoritmos simétricos.
En la actualidad se suelen usar los algoritmos de clave asimétrica para asegurar
la identificación de usuarios y proteger las transmisiones de pequeñas cantidades
de datos. Los simétricos se usan para la protección de grandes cantidades de
datos estancos. Y el uso conjunto de ambos para proteger las transmisiones de
grandes cantidades de datos.
Puede suscitar que el uso de la criptografía implique solo ventajas:
mensajes por e-mails, archivos compartidos, formularios y contraseñas en la
navegación por Internet…. Todos ellos cifrados para salvar las intercepciones en
las comunicaciones. ¿Pero quienes interceptan las comunicaciones? En la
mayoría de los casos es el sistema operativo y el antivirus, pero lo hacen para
nuestra defensa. El problema radica en que los archivos cifrados que contengan
virus y/o troyanos1 no serán detectados, por lo que una vez dentro de la
computadora pueden hacer inservible la seguridad y protección proporcionada por
nuestro software criptográfico. De poco servirá el uso de claves y cifrados cuando
estemos trabajando con un troyano instalado ya que puede interceptarlo todo.
En definitiva, para una seguridad y protección de datos, no solo basta con
el uso de software criptográfico adecuado, este debe ser complementado

1 Programa malicioso capaz de alojarse en computadoras y permitir el acceso a usuarios externos, a través de
una red local o de Internet, con el fin de recabar información o controlar remotamente a la máquina anfitriona

-3-

Aplicación Software para el Desarrollo de Tareas Criptográficas

con un antivirus y firewall2. Además se requiere por parte del usuario de un uso
responsable y consciente de la información, así como el conocimiento del
comportamiento del sistema operativo en lo que se refiere a las comunicaciones
externas.

1.1.- Objetivos.
El objetivo de este proyecto ha sido la realización de una aplicación
software, para proporcionar la capacidad de cifrar y descifrar texto de forma muy
intuitiva.
Para ello, se ha diseñado una interfaz que permite realizar las operaciones
criptográficas más conocidas y sus correspondientes gestiones de claves, a
través de un entorno similar al de un editor de texto. Los criptosistemas
soportados por esta aplicación son de clave pública y clave privada,
concretamente: el algoritmo RSA, el DES y el TDES, así como el protocolo RSA
Digital. La complejidad de estos ha sido excluida del usuario final.

1.2.- Requisitos.
Estos objetivos fueron llevados a cabo partiendo de una serie de requisitos
fundamentales. El proyecto debía requerir ejecución multiplataforma, evitar
dependencias a software externo, uso de software libre para su realización y
disponer de la extracción de la complejidad criptográfica,
La necesidad de crear un software multiplataforma fue tomada como
requisito para permitir la total compatibilidad con cualquier sistema operativo y
entorno, dejando de esta forma al usuario la elección del SO en el que se sienta
más cómodo para ejecutar el software y evitando atarlo a uno en concreto.
Relacionado con lo anterior se encuentra la ausencia de dependencia a
otros programas, pues a parte de no depender del SO3, no utiliza ni funciones, ni
procedimientos de otras aplicaciones, por lo que el software realizado es
autosuficiente e independiente.
Con vistas al desarrollo, se descartó el uso de software de propietario,
optando por el software libre, es decir, librerías del proyecto GNU4, lo que tiene
unas repercusiones legales inmediatas, y económicas, tanto para uso personal
como para comercial. Sin embargo con respecto al aspecto que presenta la
aplicación desarrollada, se utilizó una librería (de código abierto) de interfaces
gráficas de usuario que requiere de licencia para uso comercial, por lo que no es
software libre, pero si permite su uso dentro del presente marco de desarrollo.
2 Corta Fuegos, elemento de hardware o software utilizado en una red de computadoras para controlar las
comunicaciones, permitiéndolas o prohibiéndolas según las políticas de red que haya definido la organización
responsable de la red.
3
Que no dependa del SO quiere decir: que puede ejecutarse en cualquier sistema operativo, pero no por si
solo.
4
Proyecto cuya filosofía es la de desarrollar y compartir un sistema, programas, librerías… de código abierto
y uso libre (B.R.2.12).

-4-


El último requisito importante con el que se contó fue el descarte del
acceso a la configuración de parámetros irrelevantes. Esto disminuyó con
consideración, la complejidad de manejo del proceso criptográfico de cara al
usuario final.

1.3.- Fases del Trabajo.
El desarrollo de este proyecto ha constado de 5 fases claramente
diferenciadas. En ellas se han tratado aspectos como implementaciones, control
de errores, incorporación y adaptación de librerías, comunicación con el usuario y
mejoras que iban surgiendo a medida que aumentaba el código.

1.3.1.- Implementación de la clase RSA y la clase DES en
modo consola usando C++.
La Implementación de la clase RSA y la clase DES en modo consola
usando C++ fue la fase de inicio desde donde se empezó buscando y estudiando
sobre la Criptografía básica en general, a través de Wikipedias5. También para un
aporte más extenso se recurrió a la lectura del libro, Técnicas Criptográficas de
Protección de Datos [B.R.1.1]. Tras su lectura, se optó por uno de los algoritmos
criptográficos a implementar, el RSA. Elección debida no solo a la visión que
ofrece el libro de sencillez y potencia, sino a que en cualquiera de las Wikipedias
consultadas también se detallaba a este algoritmo como el más conocido y usado
de los sistemas de clave pública, el más rápido de ellos, presentando todas las
ventajas de los sistemas asimétricos e incluyendo la firma digital. Por lo que el
RSA forma uno de los pilares de la criptografía y de este proyecto [B.R.1.29-1.31].
Una vez hecha la elección del algoritmo criptográfico, se pasó a la elección
del lenguaje de programación para implementarlo. Parte importante en la cual
influyó la opinión de amigos programadores y los leves conocimientos previos
sobre el lenguaje C, Python y el usado en MatLab [B.R.2.1-2.3].
La opción de MatLab fue descartada, en primer lugar por no ser software
libre y por no permitir el control y la versatilidad que permiten lenguajes como C y
Java, no son comparables, MatLab es una herramienta matemática que incorpora
un lenguaje adaptado específico que carece de la multitud de librerías como las
disponibles para C y Java. Además se ralentiza al trabajar con número
desproporcionadamente enormes (claves) o en el caso no permite su uso.
También en los sucesivos trabajos que se hicieron con MatLab (fuera del margen
de este proyecto) se constató las escasas opciones de cara a formar una interfaz
gráfica para el usuario, aspecto estético y de manejo que constituye gran parte del
éxito de las aplicaciones.
Otra opción más reñida, fue la posibilidad de hacer la implementación del
RSA en Java ,Python o C. Lógicamente los programadores consultados defendían
su lenguaje de mayor uso, coincidiendo en que Java y Python son más sencillos
5

Documentación-Librerías online aportada, seleccionada y mantenida por usuarios de Internet de forma libre
y gratuita.

-5-


que C, pero al ser lenguajes interpretados son más lentos y exigen gran cantidad
de recursos, especialmente RAM y procesador (el cual no era problema con el
ordenador disponible). Los lenguajes interpretados no necesitan de compilador
sirviendo así para cualquier plataforma o sistema operativo… Pero como para C
existen compiladores para todo, pues tampoco esto representaba ningún
problema. Por lo que en principio parecían estar todos los lenguajes empatados,
sin embargo, si lo que se quiere es aprender uno que facilite el salto al resto
(objetivo como programador en potencia interesante), C seria la elección
adecuada como base. Si saltamos de C a Python o Java es mucho más sencillo
que al contrario y concretamente si se quiere pasar de Python a C, resulta algo
complicado, pues Python deja muchas lagunas a su propia interpretación. Python
es muy rápido de programar y el más sencillo, pero permite multitud de acciones
que en los otros lenguajes darían errores. Además cada uno de los
programadores consultados había programado o programaba en C, y todos ellos
coincidían en que ese lenguaje es el más versátil para controlarlo todo (bajo y alto
nivel), aunque para cosas especificas podría ser necesario otro que resultase más
rápido y sencillo. C aparte de que produce códigos muy eficientes, proporciona
modularidad. Está considerado como el lenguaje de programación universal y si
existen bibliotecas para lo que sea en un lenguaje concreto, es seguro de que
existirán en C, algo por ejemplo muy interesante con vistas al trabajo con
números enormes.
Teniendo el lenguaje y el algoritmo a implementar, ya solo quedaba
encontrar un entorno de desarrollo. Este fue el puesto a disputar por el
CodeBlocks [B.R.2.6] y el Dev-Cpp [B.R.2.5]. IDEs para C/C++, de software libre y
con el compilador integrado MinGW [B.R.2.7]; compilador que permite compilar
las librerías del proyecto GNU en Windows y las API’s6 de Microsoft. Tanto una
IDE como la otra, disponen de interfaces similares, simples y fáciles de usar.
Únicamente influyeron en la elección mínimos detalles de estética recargados e
idioma, pues la configuración del área de trabajo y la imposición del inglés como
único idioma en el CodeBlocks, hicieron al Dev-Cpp nuestro entorno de desarrollo
integrado preferido.
También se vio por encima la posibilidad de Visual C++, pero quedó
rápidamente descartado porque VC++ está especialmente diseñado para el
desarrollo y depuración de código escrito para las API's de MS (Microsoft
Systems) y no queremos que nuestro software dependa de este.
Disponiendo ya de todas las herramientas necesarias, se hizo la primera
implementación, el RSA en modo consola con un menú básico para la navegación
entre las posibilidades que se ofrecía (Figura 1.1). Se implementaron varias
funciones necesarias dentro del RSA como son el cálculo de un número primo y el
mínimo común divisor con Euclides. También fueron necesarias muchas otras
para el correcto funcionamiento del proceso de cifrado y descifrado, así como
para la visualización del menú. Las cabeceras de estas funciones y
procedimientos, se detallan en el Cuadro de Código 1.0, no obstante evitamos de
poner todo el código pues se trata de 281 líneas de implementación obsoleta, y
solo algunas bases se mantienen en el desarrollo final. Las partes más relevantes
referentes al RSA se verán con detalle en el Capítulo 2.
6

La API es la Interfaz de Programación de Interfaces, es decir, el conjunto de funciones y procedimientos
que ofrece cierta librería para ser utilizada por otro software con capacidad de abstracción.

-6-


Figura 1.1: Menú consola RSA (1ª Versión de la Aplicación desarrollada)

void MostrarMenu(); //muestra el menú de la Figura 1.1
bool EsPrimo(int numero); //usada en Generar_Claves
int Mcd_con_Euclides(int a, int b); //usada en Generar_Claves
void Generar_Claves(unsigned int &e, unsigned int &n, unsigned int &d); //calcula las claves
void LeerMensaje(TCadena &mensaje); //entrada texto
void EscribirMensaje(TCadena mensaje); //salida texto
void EscribirCifrado(TArrayN mensaje_cifrado, unsigned int i); //salida texto cifrado
void EscribirDescifrado(TArrayN mensaje_descifrado, unsigned int n_car); //salida descifrado
void Cifrar_Mensaje(unsigned int e, unsigned int n, unsigned int &n_car, TCadena mensaje,
TArrayN &mensaje_cifrado); //cifra con RSA
void Descifrar_Mensaje(TArrayN mensaje_cifrado,unsigned int n, unsigned int n_car);//descifra
void CargarFichero(); //carga y muestra un txt
Cuadro de Código 1.1: Cabecera de funciones y procedimientos de la 1ª Versión de la Aplicación.

De entre todas las funciones y procedimientos, únicamente se encontraron
dos problemas a destacar. Uno dentro del procedimiento “Generar_Claves”.
Donde hubo errores conceptuales en el cálculo del número inverso modular, para
la clave privada, que hacía que no se pudiera recuperar el texto en claro. Y el otro
referente al control de Overflows7 en “Cifrar_Mensaje” y “Descifrar_Mensaje”.
Solucionados gracias a ir aplicando el cálculo del resto a sucesivos productos en
vez de aplicarlo a una exponencial al final (Cuadro de Código 1.2).

while(j<=e){ mensaje_cifrado[i]=(mensaje_cifrado[i]*(int(mensaje[i])))%n; j=j+1; }
Cuadro de Código 1.2: Cálculo del resto “%” a sucesivos productos en Cifrar_Mensaje.

Solucionadas estas deficiencias se buscó otro algoritmo para implementar
que no fuese asimétrico como el RSA. Así que dentro de los algoritmos
criptográficos simétricos sobre los que se hace especialmente hincapié en el libro
de Técnicas Criptográficas de Protección de Datos [B.R.1.1], recurrimos al que es
sin duda el más conocido de los sistemas de clave privada, el DES. Este aunque
ya no se considere un sistema seguro, multitud de descendientes comparten
similitudes con el, lo que lo hace muy interesante. Representa la base del Triple
DES, el cual si es seguro, pues la aplicación sucesiva de este algoritmo mejora su
seguridad. Presenta todas las ventajas de los sistemas simétricos, y su
combinación con sistemas asimétricos permite topologías como las usadas en
7

Sobre carga de datos, salimos del margen de datos representable para el tipo definido.

-7-


SSL y PGP8. Por lo que a nivel de estudio el DES se considera una base dentro
de la criptografía y otro de los criptosistemas que no podría faltar en la aplicación
desarrollada.
Con el objetivo de ampliar el menú anterior, añadiendo las opciones
referidas a la utilización del DES junto con las del RSA, a priori se hizo una
implementación aparte donde tuviéramos el DES cifrando y descifrando
perfectamente. Una vez comprobada la ausencia de errores se adaptaría al menú
realizado.
En la primera implementación del DES, se trató la parte de encriptación y
constaba únicamente de la introducción del mensaje a cifrar, usando una clave
interna predefinida para ocultarlo (Figura 1.2).

Figura 1.2: Cifrado DES (1ª Versión de la Aplicación DES)

En lo que se refiere a la implementación del código, las operaciones
utilizadas en el criptosistema DES son mucho mas sencillas que las usadas en el
RSA, sin embargo, el proceso hasta obtener el mensaje cifrado es mucho más
largo9. Por ello, se subdividió el proceso de encriptado en varios subprocesos
para facilitar la programación y la reutilización de código. Las cabeceras de estos
se detallan en el Cuadro de Código 1.3. El número de líneas de código del que se
constaba eran de 453 y las librerías utilizadas al igual que con RSA son las
básicas de C necesarias para el uso de streams y entrada y salida de datos, entre
otras. Las partes más relevantes referentes al DES a la hora de implementarlo en
su versión final se verán junto a la teoría con detalle en el Capítulo 2.
Durante el desarrollo de esta primera versión del DES en la encriptación,
se encontraron mayor número de problemas que con la versión del RSA.
Problemas en su mayoría en el traspaso de los procedimientos del DES descritos
por el libro al código C, pues con muchas líneas de código y sin errores de
compilación, un simple error al adaptar, resultaba tedioso de encontrar. Algunos
de ellos fueron los debidos a los desplazamientos necesarios dentro del
procedimiento para las claves de ronda “generarClavesDeRonda” que producían
claves inválidas para cifrar el mensaje, y que tuvo que ser desmenuzado paso a
paso para encontrar el error existente en las variables controladoras. Se puede
8

SSL (Seguridad de la Capa de Transporte, B.R.4.2) y PGP (Privacidad Bastante Buena, B.R.4.1), protocolo
y programa, respectivamente, cuya finalidad es proteger la información distribuida a través de Internet. PGP
a parte proporciona protección para datos que no estén en transito.
9
En DES el proceso es más largo, tenemos más líneas de código, pero al utilizar operaciones sencillas como
sustituciones, permutaciones y XOR, el tiempo de proceso es menor que en RSA, donde tenemos menos
líneas de código pero operaciones más complejas, tales como el calculo exponencial y el mínimo común
múltiplo entre otras.

-8-


nombrar también el referente a cuando se programaba la Función de Feistel10, en
el entrecruce de las partes del mensaje, concretamente en el entrecruce que se
hacia en la última vuelta, el cual no debía hacerse y que conllevo cambios
innecesarios hasta su detección. Por comentar uno más, destacar el error dentro
del procedimiento “sustitución” donde se dispone de unas tablas fijas
denominadas S-Box las cuales a partir de una entrada especificada por una fila y
columna sustituyen unos bits por otros, aquí el problema fue que las coordenadas
se mantenían siempre constantes independientemente del valor de entrada, por lo
cual la salida no podía ser correcta, gracias a la depuración y visualización paso a
paso del proceso, este y otros muchos problemas se solucionaron.

void permutacionTipo1(); //usada en generarClavesDeRonda
void permutacionTipo2(); //usada en generarClavesDeRonda
void generarClavesDeRonda(); //calcula las claves de ronda a partir de una clave predefinida
void permutacionInicial(); //facilita la carga de los bits de información en bloques de 8 bits
void expansion(); //expansión de la parte derecha del mensaje
void xorTipo1E(int); //xor de la expansión de la parte derecha con la clave de ronda
void sustitucion(); //sustitución de unos bits por otros según tablas definidas
void permutacion(); //permutación fija
void xorTipo2(); //xor de la parte izquierda con el resultado de las trasformaciones de la parte
derecha
void inversa(); //inversa de la permutación Inicial
Cuadro de Código 1.3: Cabecera de procedimientos de la 1ª Versión de la Aplicación DES.

Terminada la parte del DES para la encriptación, quedaba poder recuperar
el mensaje desencriptandolo. Parte en principio sin aparente dificultad pues el
DES al estar basado en una Función de Feistel tiene la propiedad de que si se
aplica de nuevo el proceso se obtiene en mensaje en claro. De este modo se
completo el criptosistema DES presentándolo en modo consola con una
comunicación entrada salida básica (Figura 1.3).
Al ser el proceso prácticamente el mismo, podemos reutilizar todo el
código anterior (para las cabeceras de los procedimientos, véase Cuadro de
Código 1.3), resultando mínimo el aumento de número de líneas. Y solucionados
los problemas anteriores no tendría por que haberlos aquí. Únicamente existió
uno debido a copiar el algoritmo de encriptado en el de desencriptado sin hacer
variaciones. Pues al ir haciendo la “xorTipo1E” de la expansión de la parte
derecha con la consecuente copia de subClave (clave de ronda) tenía que ir hacia
atrás, en vez de cómo en el encriptado. Habría que usar “subClave[16-ronda][i]”
en vez de lo que se tenía “subClave[ronda-1][i]”. Se diseñó el procedimiento
“xorTipo1D” para el desencriptado dejando “xorTipo1E” para el encriptado.

10

Se trata de un algoritmo criptográfico simétrico por rondas. 1º Se selecciona una cadena N, de 64 o 128
bits, se divide en 2 subcadenas, L (izquierda) y R (derecha), de igual longitud (N/2). 2º Se toma una función
F y una subclave Ki. 3º Se realizan una serie de operaciones con F y Ki y con L o R (solo uno de ellos). 4º La
cadena obtenida se cambia por la cadena con la que no se han realizado operaciones y se siguen haciendo
rondas.

-9-


Figura 1.3: Cifrado y Descifrado DES (2ª Versión de la Aplicación DES)

Llegados a este punto y debido a la cantidad de código generado, y de
funciones y procesos que debieran reutilizarse, se optó por el traspaso a una
programación orientada a objetos. Se pasó de C a C++, lo cual no presentó
dificultad alguna con la ayuda de la documentación necesaria [B.R.2.4]. De este
modo se creó la clase DES y la clase RSA con sus respectivos métodos. El
siguiente paso sería incluir ambas dentro de un nivel superior con integración de
gráficos.
Todas las elaboraciones destacables llevadas a cabo durante esta fase
inicial de implementación de la clase RSA y la clase DES en modo consola
usando C++, se presenta en forma de esquema en la Figura 1.4.

1.3.2.- Adaptación de RSA y DES a Qt.
Las limitaciones gráficas y de movilidad que ofrecían las aplicaciones
desarrolladas (Menú RSA y DES), así como la organización tediosa del código a
la hora de querer añadir nuevas funcionalidades, propinó la optimización de este a
la vez que la búsqueda de una librería gráfica de usuario. El objetivo era
transformar lo que teníamos a una aplicación de escritorio, mucho más intuitiva
que las de modo consola.
La biblioteca para desarrollar interfaces gráficas de usuario tenía que
cumplir con los mismos requisitos que se plantearon al principio. Posibilidad de
integración multiplataforma, ausencia de dependencias y ser software libre.
Requisitos que cumple la librería Qt de Trolltech [B.R.2.10-2.11], la que es sin
duda la mejor librería dentro de su campo y cuyo uso está muy extendido en
plataformas Linux.
Hoy en día y gracias a las adaptaciones que se hicieron para facilitar el uso
de Qt en Windows, sin necesidad de configurar una IDE o trabajar con Cygwin o
Msys11, ocurre que entren cada vez más programadores a formar parte de los
desarrolladores que trabajan con Qt y MS.
Es necesario aclarar que el requisito de ser software libre no es del todo
aplicable para Qt, pues esta requiere de licencia para uso comercial. No obstante,
si permite su uso para el ámbito personal y para el presente marco de desarrollo.
11

Entornos de desarrollo muy similar al de Unix que permiten el uso de herramientas de desarrollo GNU
(autotools, make, gcc…) en Windows (B.R.2.8-B.R.2.9).

-10-


FASE 1

Técnicas
Criptográficas de
protección de datos

Documentación
sobre
Criptosistemas

3ª Edición Rama

Wikipedias

Páginas y Foros
dedicados

Elección de Algoritmo RSA

Lenguajes de
Programación

Documentación sobre
Recursos para su implementación

Librerías

Elección de C en Dev-Cpp

Apuntes de C

Implementación del RSA en
Modo Consola

Software de
Capacidad
numérica e
IDEs

Fundamentos
Matemáticos
necesarios

Elección de otro Algoritmo: DES

Apuntes de C

Implementación del DES en
Modo Consola

Fundamentos
Matemáticos
necesarios

Cambio del lenguaje de programación
Apuntes de
C++

Traspaso de Implementaciones de C a C++
Figura 1.4: Esquema del proceso de trabajo para la
Implementación de la clase RSA y la clase DES en modo consola usando C++

A la hora de adaptar el código a Qt se substrayeron los cometidos referidos
a la entrada y salida de datos en la comunicación con el usuario, dejando
únicamente las variables y métodos propiamente de los criptosistemas. La clase
-11-


RSA y la clase DES obtenidas no son las versiones definitivas. A parte se
prescinde de mostrar todo el código y se muestran únicamente las definiciones de
las clases (Cuadro de Código 1.4 y 1.5, “mirsa.h” y “mides.h” respectivamente),
junto con breves comentarios, ya que en el Capítulo 2 se entrará en más detalle.

#ifndef MIRSA_H
#define MIRSA_H
//Las clases definidas por Qt empiezan por “Q” seguidas de un nombre identificativo en inglés
#include <QWidget>
class QString; //igual que un include, pero hace la compilación más rápida, solo para punteros
class MiRsa : public QWidget{
Q_OBJECT //referente a los meta datos, necesario en todas las clases Qt
public:
MiRsa(QWidget *parent=0); //constructor
//Funciones
QStringList encriptar(QString); //devuelve un QStringList con el encriptado
QString desencriptar(QStringList); //devuelve un QString con el desencriptado
bool esPrimo(int); //devuelve si un número es primo
int mcdEuclides(int, int); //devuelve el máximo común divisor de dos números
//Variables
int p,q; //números primos
int e,n; //clave Pública

int d; //clave Privada
};
#endif
Cuadro de Código 1.4: Definición de la clase “mirsa” con Qt.

Aunque la declaración de la clase DES pueda parecer muy distinta a la de
RSA, no lo es. Ambas declaraciones contienen en su parte pública los métodos
que deben caracterizar a todo algoritmo criptográfico: una función para encriptar y
otra para desencriptar. Particularmente en la definición de la clase DES toda la
parte privada es básicamente la descrita en el Cuadro de Código 1.3, con la única
diferencia de que se han creado funciones nuevas para la gestión de claves y de
que en este caso mostramos las variables y arrays que se usan en cada parte del
proceso. La definición de la clase RSA es pública íntegramente. Estas decisiones
en la implementación fueron tomadas con vistas a una idea concreta para la
gestión de claves, basada en un diálogo de menús emergentes que guiara al
usuario hasta obtener el mensaje cifrado o descifrado (véase Fase 4: Apartado
1.3.4).
Se debe aclarar que la ausencia de destructores de clase se sustenta en la
utilización únicamente de punteros a objetos de las clases Qt. Estos poseen la
propiedad de llamar a sus propios destructores. Para cualquier otro tipo de
objetos que utilicen memoria dinámica es necesario declarar e implementar un
destructor, de lo contrario se generarian espacios de memoria inutilizables.
Todas las elaboraciones destacables llevadas a cabo durante esta segunda
fase, la fase de adaptación de la clase RSA y la clase DES a Qt, se presentan en
forma de esquema en la Figura 1.5.
-12-

#ifndef MIDES_H
#define MIDES_H
#include <QWidget>
#include <QString>
class MiDes : public QWidget{
Q_OBJECT //referente a los meta datos, necesario en todas las clases Qt
public:
MiDes(QWidget *parent=0); //constructor
//Funciones
QStringList encriptar(QString); //devuelve un QStringList con el encriptado
QString desencriptar(QStringList); //devuelve un QString con el desencriptado
bool adaptarDefinidaOk(unsigned int); //sustituye clave interna por la definida
private:
//Funciones
void permutaciónInicial(); //facilita carga en bloques (usada en Cifrado-Descifrado)
void Expansión(); //hace una expansión de la parte derecha (E-D 16 Rondas)
void xorTipo1E(int); // XOR de la expansión de la parte derecha con las subclaves (E 16 R)
void xorTipo1D(int); // XOR de la expansión de la parte derecha con las subclaves (D 16 R)
void sustitución(); //hace una sustitución haciendo uso de las S-Box (E-D 16 Rondas)
void permutación(); //cambio simple de unos bits por otros (E-D 16 Rondas)
void xorTipo2(); //XOR con la parte derecha y la izquierda actuales (E-D 16 Rondas)
void inversa(); //invierte la permutación inicial (E-D)
void permutaciónTipo1(); //usada en Keygen
void permutaciónTipo2(); //usada en keygen
void keygen(); //genera las subClaves de rondas
void restaurarCPrivada(); //vuelve a poner la clave interna
//Variables auxiliares
int permuTipo1[56]; //para la permutacionTipo1 de claveIni[64]
int mitadA_pT1[28]; //para la primera mitad de permuTipo1[56]
int mitadB_pT1[28]; //para la segunda mitad de permuTipo1[56]
int a[48]; //para la permutacionTipo2 de mitadA_pT1[28] y mitadB_pT2[28]
int subClave[16][48]; //para las subClaves de las rondas, subClave[0][k]=a[k]...
int mensajeEnBinario[64]; //para el mensaje en formato binario
int permuInicial[64]; //para facilitar la carga de mensajeEnBinario[64] en bloques de 8 bits
int left[32]; //para la parte izquierda del mensajeEnBinario una vez hecha la permuInicial
int right[32]; //para la parte derecha del mensajeEnBinario una vez hecha la permuInicial
int temp[64]; //para las partes left[32] y right[32]
int expansion[48]; //para la expansion de la parte derecha right[32]
int xor1[48]; //para la xorTipo1, xor con la expansion de la parte derecha y las sublclaves
int sus[32]; //para la sustitucion mediante las S-Box de xor1
int per[32]; //para la permutacion de sus[32]
int xor2[32]; //para la xorTipo2 de left[32] y per[32]
int inv[8][8];//para la inversa de la concatenación de left[32] y right[32], terminadas las rond
int clave[64]; //para alojar la clave que se utilizara, definida o interior
};
#endif
Cuadro de Código 1.5: Definición de la clase “mides” con Qt.

1.3.3.- Diseño y desarrollo de la Interfaz.
Las limitaciones de un diseño para consola suscitaron la elección de la
-13-


biblioteca Qt (Apartado 1.3.2). Sin embargo antes de implementar la interfaz se
deben tener claras ideas como la funcionalidad que se ofrecerá de cara al usuario
final y el compromiso entre diseño atrayente y ameno, y la facilidad de uso que se
pretenden, pues tampoco se quiere complicar al usuario con una recarga de
elementos de valor estético únicamente.
Un triunfo asegurado seria imitar el estilo de la mayoría de las aplicaciones
de escritorio. Estilo que todo el mundo usa y que proporciona cierto conocimiento
sobre donde pueden estar las opciones necesarias del programa. Este es el caso
de navegadores, procesadores de texto, programas de diseño… entre otros, que
comparten los elementos básicos característicos de toda aplicación: la Barra de
Menús, la Barra de Herramientas, el Área de Trabajo y la Barra de Estado. No
obstante se optó por la opción arriesgada de innovar. Para ello se creo un Widget
(elemento base en Qt) formado por varias partes movibles que reaccionaban al
pulsar ciertos botones y al situarse sobre ciertas partes de la interfaz (1ª Versión
de la Aplicación conjunta RSA-DES). Básicamente era una barra que guiaba al
usuario a través de las dos posibles opciones para lo que en principio se
implemento: el encriptado con RSA o DES. Esta aplicación se abría (efecto muy
conseguido) al seleccionar cada opción mostrando las nuevas posibilidades en su
caso, y en el paso de un estado a otro, la barra se cerraba mostrando un texto
explicativo de la operación que se estaba realizando. El aspecto que puede
suscitar a primera vista es el de un reproductor de sonido (Figura 1.6. Barra
Dinámica) y la navegación que proporcionaba no fue la esperada, así como la
falta de espacio a la hora de querer incorporar nuevas acciones por tratarse de un
diseño tan compacto. Dimensiones que a su vez daban la impresión de que la
aplicación aportarse pocos recursos. Por todos estos motivos se paro el proceso
de desarrollo y se busco una interfaz más común. Una interfaz básica de
aplicación de escritorio como la que se comentaba al principio del párrafo.
La nueva aplicación de escritorio diseñada (2ª Versión de la Aplicación
conjunta RSA-DES) integra las propiedades y herramientas básicas de un editor
de texto. En principio solo permitía un área para redactar y las funciones en su
estado simple de cifrar y descifrar. Paso a paso se fueron implementando las
funciones de copiar, cortar, pegar, seleccionar… realizables por menús, teclado o
ratón. Esta última para el caso de seleccionar proporciona gran comodidad, pues
mediante doble clic o arrastrando el cursor se pueden indicar de forma muy rápida
las partes del texto escrito a las que se desea aplicarle uno de los dos
criptosistema. En base a las ejecuciones, la ejecución del DES era inmediata,
pues se sustentaba en una clave fija predefinida. Sin embargo para la ejecución
del RSA se configuró un menú en el que poder elegir los números primos
necesarios de una lista, así como el resto de parámetros necesarios (claves
públicas n y e, y clave privada d).
Cada parte que se iba realizando era testeada en ejecución real y hasta
que no funcionase perfectamente no se pasaba a la siguiente implementación. Se
hacía un constante bombardeo de pruebas que en muchos casos requerían
repetir pasos o volver al estado anterior, obligando a borrar todo y empezar de
nuevo. Así por motivos de realización apareció la necesidad de un “deshacer” en
el menú principal, ya que cada vez que se quería repetir una de las fases había
que repetir todos los pasos de nuevo. Esta funcionalidad se dejó también para el
usuario final ya que un “deshacer” es muy interesante para cualquier software
(posteriormente también se crearía el “rehacer”).
-14-


FASE 2

Personal Informático
Desarrolladores de
Interfaces

Documentación
sobre librerías
Gráficas

Foros de
C++

Elección de Qt como librería

Qt Designer

Documentación sobre
Recursos para su implementación

Qt a nivel de
Programación

Elección de Qt a nivel de Programación

www.qtforum.org

Adaptación de RSA a Qt

Referencia de
la API

www.qtforum.org

Adaptación de DES a Qt

Referencia de
la API

Ideas y estructuras para gestión de claves
Adaptación de la clase RSA y la clase DES a Qt

A medida que se avanzaba en el código aparecían más detalles necesarios
de implementar. La posibilidad de guardar y cargar archivos, crear nuevos
documentos, o gestionar la posición y dimensiones de la aplicación para que el
usuario pueda cambiarlas y se mantengan en ese estado para las próximas veces
que se ejecute. Estas y el resto de las acciones junto con el resto de la interfaz
base se pueden ver en su declaración en el Cuadro de Código 1.6, clase
“miproject”, la cual se puede considerar como el “container” de todas las demás
clases existentes de la aplicación, es decir, la clase principal en la que se sujetan
las demás. La parte de la implementación ha sido omitida pues son 520 líneas de
código de las cuales solo se mostraran algunas partes más relevantes en la
siguiente fase de trabajo (Apartado 1.3.4) y en el Capítulo 3.
Gracias al bombardeo de pruebas se pudieron advertir la existencia de
defectos en las implementaciones de RSA y DES desarrolladas en las fases
-15-


anteriores. Defectos como la imposibilidad de recuperar el mensaje en claro en
RSA a partir del texto codificado (en código ASCII). Cuando se calcula el código
de cifrado de una letra (según los parámetros de las claves generadas que se han
seleccionado), este valor puede salirse del máximo representable de la tabla
ASCII. Así actuaría como un cálculo del módulo en función de la longitud máxima
del código y no podríamos saber cuantas vueltas a dado recuperando algo distinto
del mensaje original. Para solventar semejante defecto se paso de la
representación alfabética a la numérica, siendo diferenciada las partes
encriptadas por puntos. Con DES se hizo lo mismo, pero este criptosistema
presentaba aparte otro error debido a un desplazamiento en la codificación en
bloques de 8 bits. Según se seleccionase un texto u otro en DES, si su longitud
no era múltiplo de 8, su resto representaría el número de espacios hasta el
siguiente carácter. Para solventar este otro problema simplemente se sustrajo a la
longitud del descifrado obtenido el resto, eliminándose así todos los posibles
espacios del final.
La definición de la clase “miproject” presentada (Cuadro de Código 1.6),
muestra al igual que en todos los cuadros de código, breves comentarios sobre la
funcionalidad de sus métodos y variables así como el uso de los objetos que
adopta de otras clases. A diferencia del resto de clases en la que existe un
constructor y varias funciones públicas necesarias, aquí solo se presenta el
constructor pues no son necesarios ningún tipo de comportamiento o
configuración, un objeto de esta clase nos da la presentación de la aplicación.
Además se posibilita la opción en el constructor de empezar la aplicación con la
carga de un archivo por defecto.
Al observar el código puede presentar dudas el hecho de que aparezcan
por primera vez métodos con sus cabeceras en inglés, pudiendo definirlas en
español como hasta ahora. La cuestión es que no se puede. No son iguales que
el resto de métodos, pues representan al ámbito de funciones en Qt para el
control de eventos, que pueden ser reimplementadas (cuyas cabeceras son fijas).
Tales eventos como clickeos de ratón, entradas de teclado, eventos comunes de
las aplicaciones como abrir, cerrar… disponen de estos métodos específicos para
tratarlos. Todos ellos permiten utilizar otras funciones existentes en la clase o
reimplementar todo el código en la medida de lo que sea necesario.
Tratándose del diseño de cada botón de la barra de herramientas. Pese a
que Qt ofrece buenos resultados y rápidos para pintar degradados, bordes,
algunos sombreados…, (acabados simples) se debe recordar que su cometido no
es para la realización de dibujos en general, aunque sea una herramienta dentro
del ámbito gráfico. Qt puede permitir acabados de dibujos realmente buenos pero
estos más que nada dependen de la pericia del diseñador, pues para la mayoría
de usuarios de Qt esta tarea resulta extremadamente engorrosa. Es por ello que
las herramientas propias de dibujo de Qt, así como la posibilidad de configuración
mediante StyleSheet (a través de código CSS12) que incorpora, pueden limitar al
diseñador en estos casos particulares, por lo que se opta por herramientas de
diseño gráfico como Gimp (software libre) o Photoshop (software propietario)13,
12

CSS es un lenguaje formal de hojas de estilo en cascada (Cascading Style Sheets) que describe como se va
a mostrar un documento en pantalla. Utilizado para definir la presentación de documentos en HTML o XML
13Aunque las posibilidades de Photoshop (B.R.5.1-5.2), motivadas por inversiones de millones de dólares,
superan con creces a las de Gimp (B.R.5.3), , Gimp gana terreno a paso de gigante gracias a las
colaboraciones que se hacen a través de usuarios y programadores de todo el mundo (Filosofía GNU)

-16-


para crear los dibujos que irán en botones, barras, o áreas concretas de la
aplicación.

#ifndef MIPROJECT_H
#define MIPROJECT_H
#include <QMainWindow>
class QAction;class QMenu;class QTextEdit;
#include "micriptosistema.h"
class MiProject : public QMainWindow{
Q_OBJECT
public:
MiProject();//constructor base
MiProject(const QString & nombreArchivo);//constructor que carga archivo
protected:
//Función reimplementada
void closeEvent(QCloseEvent *evento);//guarda los settings y aviso guardar cuando cerramos
private slots:
void nuevo();//crea un nuevo archivo
void abrir();//abre un archivo existente con extensión
bool guardar();//permite guardarArchivo (sinTitulo) o guardarComo(!sinTitulo)
bool guardarComo();//guarda el archivo caso de estar ya guardado
void encriptar();//pasos previos al encriptado del texto seleccionado
void encriptando();//encripta con los parámetros seleccionados
void desencriptar();//paso previo al desencriptado del código seleccionado
void desencriptando();//desencripta con la clave privada
void documentoModificado();//pone setWindowModifed(true)
void acercaDeCriptoYenet();//muestra en que consiste la Aplicación
private:
void iniciar();//configuración de parámetros básicos
//Actuan sobre los elementos básicos de la Aplicación
void crearAcciones();//crea las acciones que me permite hacer la Aplicación
void crearMenus();//crea accesos a las acciones en los menús Archivo, Edición...
void crearBarraDeHerramientas();//crea accesos rápidos a las acciones
void crearBarraDeEstados();//crea una barra de información
//Actúan sobre el aspecto de la Aplicación a nivel de usuario
void leerParametros();//lee y pone la pos y el size guardados en settings o la x defecto
void escribirParametros();//escribe la pos y el size que hemos puesto en settings
//Abrir y Guardar
bool posibleSalvar();//salva o no cambios pendientes en el documento
void cargarArchivo(const QString &nombreArchivo);//carga un archivo
bool guardarArchivo(const QString & nombreArchivo);//guarda el archivo donde indiquemos
Cuadro de Código 1.6: Definición de la clase “miproject” con Qt (Parte 1/2).

-17-

//Actuan en el caso de usar RSA
void posibleSalvarClavesRSA();//salva o no las claves públicas generadas
bool guardarClavesPúblicasRSA(const QString nombreArchivo);//guarda n y e
//Actualiza titulo y pone flags de documento modificado a false
void actualizarArchivo(const QString & nombreArchivo);
//Devuelve el nombre del documento
QString darNombreArchivo(const QString & nombreArchivo);
//Para encontrar el archivo fileName de entre los abiertos
MiProject *encontrarMiProject(const QString & nombreArchivo);
//Menus
QMenu *menuArchivo;//contiene acNuevo, acAbrir, acGuardar, acGuardarComo, acCerrarV
y acSalir
QMenu *menuEdicion;//contiene acDeshacer acRehacerac, Cortar, acCopiar, acPegar y
SelectAll
QMenu *menuCriptosistema;//contiene acEncriptar y acDesencriptar
QMenu *menuAyuda;//contiene acAcercaDeCriptoYenet, acAcercaDeRsa y acAcercaDeDes
//Barras de Herramientas
QToolBar *barraArchivo;//contiene acNuevo, acAbrir y acGuardar
QToolBar *barraEdicion;//contiene acDeshacer acRehacerac, Cortar, acCopiar, acPegar y
SelectAll
QToolBar *barraCriptosistema;//contiene acEncriptar y acDesencriptar
//Acciones
QAction *acNuevo;QAction *acAbrir;
QAction *acGuardar;QAction *acGuardarComo;
QAction *acCerrarVentana;QAction *acSalir;
QAction *acDeshacer;QAction *acRehacer;
QAction *acCortar;QAction *acCopiar;QAction *acPegar;
QAction *acSelectAll;
QAction *acEncriptar;QAction *acDesencriptar;
QAction *acAcercaDeCriptoYenet;
//Mi editor de Texto
QTextEdit *editorTexto;
//QStrings
QString text;//para el mensaje a encriptar
QString codigo;//para el codigo a descifrar
QString archivoActual;//nombre del archivo actual
QString archivoCPActual;//nombre del archivo de las claves públicas actuales
//Boleanas
bool sinTitulo;//indica si el documento tiene titulo o no
//Manejadores
QClipboard *portapapeles;//lo utilizamos en encriptar y desencriptar
MiCriptosistema *cripto;//permite encriptar/desencriptar usando rsa o des…
};
#endif
Cuadro de Código 1.6: Definición de la clase “miproject” con Qt (Parte 2/2).

No obstante, para lo que se necesita ambos programas dentro del presente
desarrollo, estos aportan las mismas prestaciones. Se optó por Photoshop (en
-18-


una versión limitada pero libre, entrando así dentro de los requisitos que se
plantearon para el desarrollo de la aplicación) por ser el software al que se esta
más acostumbrado. Tras la integración de los dibujos en el background de los
botones y finalizada las nuevas implementaciones que propinó la interfaz
seleccionada, se contaba con el aspecto base final de la aplicación.
Todas las elaboraciones destacables llevadas a cabo durante esta tercera
fase, la fase de diseño y desarrollo de la interfaz, se presentan en forma de
esquema en la Figura 1.6.
FASE 3

Diseño
de posibles
Interfaces

Photoshop

Estilo
Barra
Dinámica

Estilo
Aplicación
Windows XP

Mínima Implementación
Elección de Estilo Aplicación Windows XP

www.qtforum.org

Implementación de funciones
básicas de un editor de texto e
incorporación de las propias de
todo sistema criptográfico

Referencia de
la API de Qt

Diseño de botones
Figura 1.6: Esquema del proceso de trabajo para el
Diseño y desarrollo de la Interfaz de la Aplicación

-19-


1.3.4.- Gestión de claves e implementación de la clase TDES
y RSA Digital.
A finales de la fase anterior se consiguió una versión de la aplicación con
las prestaciones que se definieron para el cifrado y descifrado de texto. Sin
embargo la parte del acceso y configuración de las claves necesitaba de una
adecuada implementación para su gestión.
La gestión de claves realizadas para los criptosistemas desarrollados son
diferentes, debido a su naturaleza en las claves. Con el caso de RSA (algoritmo
de clave pública) se usan un par de claves públicas y una clave privada mientras
que para el caso de DES (algoritmo de clave secreta) se usa únicamente una
clave privada.
Especificando para el caso de RSA se han implementado 3 opciones. La
primera de ellas es la posibilidad de Generar las claves. Con sus comienzos en
las primeras fases, pues según se planteó la generación a partir de primos
(“creación desde cero”) es necesario seguir una secuencia característica del RSA
hasta obtener el par de claves públicas y la clave privada, que permiten el cifrado
y descifrado. Diseñadas las elecciones de los números primos, así como el
cálculo del divisor “n”, la elección del exponente “e” y por último del cálculo del
exponente privado “d”, se hicieron dos mejoras en la generación: una necesaria
para solventar la demora en el cálculo del mínimo común divisor y la otra se trató
de la incorporación de un deshacer. En el caso de la primera, el cálculo del “mcd”
presentaba varias posibles implementaciones para su uso, siendo la más
adecuada para realizar en una computadora la referente al método iterativo
[B.R.2.15]. Esta suplanto a la versión formal desarrollada por Euclides que se
tenía.
Terminados los cambios en la implementación del “menú generar”, se
detectó que una vez guardado un documento cifrado, si este se quería descifrar
en otra sesión de la aplicación, no se podía al menos que se repitiera
exactamente el mismo proceso de generar las claves con el que se cifró el
mensaje. Consecuencia que representaba una gran deficiencia, pues no facilitaba
las comunicaciones con usuarios que dispongan del programa, a menos que se
pasen los números primos y las elecciones, lo cual rompería la seguridad. Esta
limitación se solventó gracias a la implementación de un detector de claves
(usadas durante la sesión) que guarda las claves en un archivo a petición del
usuario, y al desarrollo de la segunda opción de gestión de claves implementada
en el “menú cargar”. Esta última, la del “menú cargar”, dispone de una parte en la
que se puede introducir el par de claves públicas de manera manual y en la otra a
través de archivo (cargando el archivo generado con el detector de claves
usadas). También se ideó un “menú sesión” (3ª opción), surgido de manera
automática como consecuencia del detector, pues se vio la necesidad de que en
algún momento el usuario podría desear reutilizar claves de una misma sesión.
Tanto la parte de encriptar como la de desencriptar en RSA disponen de
los mismos menús, pues son igualmente necesarios. Así lo que se hizo fue
reutilizar código y para el caso concreto del desencriptado activar un menú final
en el que se pidiera la clave secreta de usuario para recuperar el mensaje.
-20-


El otro caso, el de la gestión de claves del criptosistema DES, es bien
distinto. Aquí no existe un proceso para generar la clave privada sustentado en
los entresijos matemáticos, como la multiplicación de primos elevados o las
propiedades de la modularidad al orden de la criptografía. Tampoco son
necesarias unas claves para cifrar y otras para cifrar. Simplemente se define una
clave privada de longitud fija (64 bits) que es utilizada en ambos procesos.
Lo que se hizo fue mantener el recurso de clave implementado en
inversiones anteriores. Es decir, el uso de una clave fija predefinida a nivel de
programación (clave interior). Esta ahora sería útil para una comunicación entre
todos los poseedores del programa, pero no se garantizaría la seguridad por la
intersección de terceros. La que verdaderamente aportaría seguridad fue la
adición de la posibilidad de elegir la clave, mediante la implementación del “menú
definir”.
Otra diferencia con el diálogo de menús de gestión de RSA es que en DES
la parte de cifrado es exactamente la misma que la de descifrado, debido a que se
usa una clave para todo. Para facilitar la navegación a través de estos diálogos
emergentes que guían al usuario, se implementó un “avanzar” y un “retroceder”
que permiten saltar entre las distintas opciones. Se puede ver la declaración de la
clase que controla estos diálogos haciendo la gestión de claves y que también
permite el uso de los criptosistemas en el Cuadro de de Código 1.7. Dicha clase
denominada “micriptosistema” es en la que la clase principal “miproject” delega el
cometido propio del uso de los criptosistemas. La parte de implementación de
“micriptosistema” posee 600 líneas y es la que ha sufrido más incorporaciones y
reajustes durante la realización del software. De esta se introducirán varias partes
de código en el Capítulo 2.
Llegados a este punto y debido al diseño reutilizable de las clases
implementadas, resurgió una idea de implementación aparecida en las primeras
fases de documentación: La implementación de Triple DES. La cual con tan solo
algunos ajustes puede reutilizar todo el código de DES. Ambas declaraciones son
iguales con lo que se puede recordar el Cuadro de Código 1.5. En su
implementación únicamente se aumentó la longitud de clave y se introdujo todo el
proceso de sustituciones, permutaciones y XORs dentro de un bucle de 3 vueltas
que utiliza claves de longitud DES (64bits). Esta clave de 64 bits correspondientes
a trozos de la clave de longitud TDES (192).
La última incorporación al “menú criptosistemas” surgió tras la lectura de un
artículo [B.R.4.1] en el que se comentaba el poder del uso de la criptografía
simétrica y asimétrica usada en las topologías SSL y PGP (brevemente
comentadas en apartados anteriores). Concretamente hablaba del sobre RSA
Digital, un protocolo bastante potente que usa RSA para ocultar la clave privada
de DES y transmitirla, y DES para la comunicación de información. Se
aprovechan las mayores ventajas de cada parte: RSA es lento pero proporciona
un canal seguro y DES es rápido pero no dispone de un canal seguro por lo que
se complementan perfectamente. Así que aprovechando que se tenía
implementada la clase RSA y DES se conformó este protocolo dentro de la clase
“micriptosistema”. No se implemento una clase aparte como con RSA, DES y
TDES porque al tratarse de un protocolo su desarrollo resultaba mucho más
sencillo dentro de la clase “micriptosistema”, cuya estructura requería de mínimos
ajustes que favorecían la incorporación en este sentido.
-21-


Implementada RSA Digital con RSA y DES, no se podía desaprovechar la
oportunidad de incorporar RSA Digital con RSA y TDES habiendo implementado
TDES. Algunas partes referentes a este código dentro de la clase
“micriptosistema” se verán en el Capitulo 2, para las definiciones referentes a RSA
Digital y los objetos de la clase TDES dentro de esta, ver Cuadro de Código 1.7.
Como se puede apreciar en el Cuadro de Código 1.7, cada elemento de la
declaración de la clase “micriptosistema” aparece brevemente comentado al igual
que cualquier otro cuadro de código. Se pueden destacar las similitudes de los
métodos pertenecientes a RSA, DES, TDES y RSA Digital, los cuales permiten la
introducción de valores adecuados, y la comunicación con las respectivas clases
de cada algoritmo mediante los manejadores de objetos declarados al final (RSA
Digital utiliza la combinación de dos de ellos según sea el caso) y los diálogos
creados. Estos diálogos son los objetos para la gestión de claves; están definidos
en “private” en la parte de “Diálogos” (se han intentado que los nombre de sus
clases y las del resto sean identificativos).

#ifndef MICRIPTOSISTEMA_H
#define MICRIPTOSISTEMA_H
#include <QWidget>
#include <QTime>
class QDialog;class QPushButton;class QLabel;class QStringList;
#include "mirsa.h" #include "mides.h" #include "mitdes.h"
#include "migenecargosesirsa.h" #include "midefinirointeriordes.h" #include "midesotdes.h"
class MiCriptosistema : public QWidget{
Q_OBJECT
public:
MiCriptosistema(QWidget *parent= 0);
//Funciones Generales
void elegirAlgoritmoEncriptado();//permite seleccionar el algoritmo para el encriptado
void elegirAlgoritmoDesencriptado();//permite seleccionar el algoritmo para el desencriptado
int getAlgoritmo();//me devuelve el numero identificativo del algoritmo seleccionado
//Funciones RSA
QString encriptarRSA(QString);//devuelve el mensaje encriptado
QString desencriptarRSA(QString);//devuelve el código desencriptado
QStringList* getListaCPsRSA();//devuelve las claves públicas
//Funciones DES
QString encriptarDES(QString);//devuelve el mensaje encriptado

QString desencriptarDES(QString);//devuelve el código desencriptado
//Funciones Triple DES
QString encriptarTDES(QString);//devuelve el mensaje encriptado
QString desencriptarTDES(QString);//devuelve el código desencriptado
signals:
void encripta();//indica q ya se han elegido los parámetros de encriptado del algoritmo
void desencripta();//indica q ya se han elegido los parámetros de desencriptado
void tomaCPsListaRSA(QStringList*);//indica la lista de pares de claves públicasRSA
Cuadro de Código 1.7: Definición de la clase “micriptosistema” con Qt (Parte 1/3).

-22-

private slots:
//Funciones RSA
void mostrarDiálogoEncriptarRSA();//muestra el diálogo para encriptar
void mostrarDiálogoDesencriptarRSA();//muestra el diálogo para desencriptar
void darListaClavesPúblicasRSA();//emite listaClavesPúblicasRSA
void ponerClavesPúblicasRSA(int, int);//pone las claves públicas
void ponerClavePrivadaRSA(int);//pone la clave privada
//Funciones DES
void mostrarDiálogoEncriptarDES();//muestra el diálogo para encriptar
void mostrarDiálogoDesencriptarDES();//muestra el diálogo para desencriptar
void ponerClavePrivadaDES(int);//pone la clave privada
//Funciones TDES
void mostrarDiálogoEncriptarTDES();//muestra el diálogo para encriptar
void mostrarDiálogoDesencriptarTDES();//muestra el diálogo para desencriptar
void ponerClavePrivadaTDES(int);//pone la clave privada
//Funciones RSA Digital
void mostrarDiálogoEncriptarRSADigital();//muestra el diálogo para encriptar
void mostrarDiálogoDesencriptarRSADigital();//muestra el diálogo para desencriptar
void cPrivadaDESRSAD(QString);//pone la clave privada
void cPrivadaTDESRSAD(QString);//pone la clave privada
void abandonar();//cierra los diálogos
private:
//Funciones
void crearDiálogoRSA();//crea el diálogo referente al algoritmo RSA
void crearDiálogoDES();//crea el diálogo referente al algoritmo DES
void crearDiálogoTDES();//crea el diálogo referente al algoritmo TDES
void crearDiálogoRSADigital();//crea el diálogo referente al algoritmo RSA Digital
void crearDiálogoAlgoritmos();//crea el diálogo referente a la elección de algoritmos
void posibleGuardarClaveRSAD();//diálogo anterior a guardarClaveRSAD
bool guardarClaveRSAD(QString);//guarda la clave privada simétrica de RSA Digital
//Diálogos
QDialog *dAlgoritmosEncriptado;//permite seleccionar entre los algoritmos disponibles
QDialog *dAlgoritmosDesencriptado;//permite seleccionar entre los algoritmos disponibles
MiGeneCargOSesiRSA *dEncriptarRSA;//permite generar las claves, cargarlas o usar sesión
MiGeneCargOSesiRSA *dDesencriptarRSA;//permite generar las claves, cargarlas o sesión
MiDefinirOInteriorDES *dEncriptarDES;//permite escribir la clave o usar la predefinida
MiDefinirOInteriorDES *dDesencriptarDES;//permite escribir la clave o usar la predefinida
MiDefinirOInteriorDES *dEncriptarTDES;//permite escribir la clave o usar la predefinida
MiDefinirOInteriorDES *dDesencriptarTDES;//permite escribir la clave o usar la predefinida
MiDESOTDES *dEncriptarRSADigital;//permite elegir DES o TDES
MiDESOTDES *dDesencriptarRSADigital;//permite elegir DES o TDES
//StringList
QStringList *listaCPsRSA;//lista de claves públicas usadas durante sesión


-23-

//Time
QTime time;//registramos hora de uso de claves públicas RSA
//Manejador RSA
MiRsa *rsa;//algoritmos de RSA
//Manejador DES
MiDes *des;//algoritmos de DES
//Manejador TDES
MiTDes *tDes;//algoritmos de Triple DES
bool encriptar;//indica encriptar true, desencriptar false
int algoritmo;//indica el tipo de algoritmo (0: RSA, 1: DES, 2: Triple DES)
bool protocoloRSAD;//indica que estamos usando el protocolo RSA Digital,
QString cPrivadaSimetricaRSAD;//indica la clave privada del algoritmo Simétrico en RSADig
QString cPrividaSimetricaRSADCifrada;//indica la clave privada de RSA Digital
};
#endif

En lo que se refiere a las señales, “encripta” y “desencripta”, son
sumamente importantes pues saltan a la clase “miproject”. Cuando se activan
indican que se han terminado de seleccionar los parámetros para el encriptado o
desencriptado, delegando la finalización de la tarea a “miproject”.
Las diferencias entre el uso de claves de estos criptosistemas, aclarada
brevemente al principio de este apartado (para más detalle véase el Capítulo 2),
se puede apreciar en los métodos implementados en la parte de “private slots”.
En esta fase también se arreglaron una serie de problemas. Es el caso de
las limitaciones de longitud a la hora de seleccionar el texto, que se solucionó
gracias al uso de memoria dinámica y a la clase “lista” definida por Qt. Una vez
ilimitada la selección se comprobó que para el caso concreto de DES y TDES no
se cifraba bien el mensaje para longitudes grandes, nuevo error debido al uso de
arrays con el mensaje transformado.
Íntegramente en esta fase se hicieron las clases para la gestión de claves y
la clase TDES. La clase “micriptosistema” tuvo su primera implementación en la
fase 3 (fase de diseño y desarrollo de la interfaz) pero se ha querido incluir aquí
su comentario pues es en esta fase cuando adquirió mayor cuerpo. En el
Apartado 1.5 se podrán apreciar la relación entre las clases implementadas y las
fases de trabajo en forma de diagrama.
Todas las elaboraciones destacables llevadas a cabo durante esta cuarta
fase, la fase de gestión de claves e implementación de las clases TDES y RSA
Digital, se presentan en forma de esquema en la Figura 1.7.

-24-


FASE 4

Gestión de Claves con RSA

Implementación
de Generar

Implementación
de Carga

Implementación
de usadas Sesión

Gestión de Claves con DES

Implementación
de Definir

Heredan

Implementación
de usar Interior

Elección de otro Algoritmo: TDES

Implementación del TDES
Hereda

Fundamentos
necesarios

Elección de otro Algoritmo: RSA Digital

Implementación del RSA Digital

Fundamentos
necesarios

Gestión de claves e implementación de las clases TDES y RSA Digital

1.3.5.- Incorporación de la Librería de Múltiple Precisión
Aritmética de GNU (GMP).
Terminada la fase 4, el software, al que se le bautizo como CriptoYenet, se
consideraba concluido, así que se paso a testearlo probando todas las
posibilidades que permite. Todo funcionaba a la perfección exceptuando un gran
problema que se descubrió relacionado con la seguridad que dota la longitud de la
clave.
En los criptosistemas ocurre que a mayor longitud de clave utilizada más
seguro es el sistema, pues aumenta el nivel de dificultad para averiguarla al
ampliarse exponencialmente el margen de posibilidades. Sin embargo en
CriptoYenet al aumentar la longitud resultaba que no se podía recuperar el
-25-


mensaje. Tras numerosas investigaciones, se observó que este problema era
debido a que se sobrepasa el máximo número representable por la computadora.
Este número un entero (int) tiene un valor máximo, el cual si se sobrepasa se
vuelve a empezar por el mínimo valor. El tipo de problema no era nuevo pues ya
apareció algo similar en fases anteriores cuando se sobrepasaba el máximo valor
representable en código ASCII. Esto aportaba ciertas ideas, pero no una solución,
pues en este caso el arreglo aplicado anteriormente no era valido al tratarse de
números. Así que se pensó en utilizar enteros positivos (unsigned int) cuyo
margen es mayor u otros tipos de datos, pero también al final la limitación
resultaba un problema que tarde o temprano surgía. Se necesitaba representar
enteros positivos sin límite de longitud, por lo que se pensó en utilizar cadenas de
caracteres para representar los números y hacer las operaciones matemáticas
con ellas. Fácil planteamiento pero difícil realización, por lo que se opto por
buscar una librería que ya implementase esta funcionalidad. Se encontró
“BigNum”, pero desgraciadamente era para Java. Casi por desistir al no
encontrarse algo similar para C/C++, apareció gracias a un foro de programación,
la mejor y más rápida biblioteca de precisión aritmética, la GMP, y encima del
proyecto GNU con lo que se podría utilizar sin problemas y cumplía los requisitos
de desarrollo. Así que se dispuso a hacer lo necesario para utilizarla. Se
compilaron los códigos fuentes para Windows XP con MSYS creando las librerías
para el sistema y la declaración de esta. Luego se incluyeron los archivos
generados en el ámbito del compilador MinGW. Dentro de este en la carpeta para
librerías “lib” se introdujo “libgmpxx.a” y “libgmp.a” y en la parte de inclusión de
cabeceras “incluye” se introdujo “gmpxx.h”. Se cambiaron los enteros “int” por el
nuevo tipo “mpz_class”, se adaptaron todas las clases menos la principal
“miproject”, ya que solo en la parte esencialmente criptográfica eran necesarios
estos cambios, es decir, de la clase “micriptosistema” hacia abajo (ver Apartado
1.5). Realizados los nuevos ajustes ya solo queda incluir en el archivo “.pro”14 las
librerías GMP con su correspondiente dirección.
Esta parte trajo numerosos problemas de cara a la configuración del
sistema. La escasa información que se documentaba al respecto en la página
oficial y foros hizo que ante la imposibilidad de utilizar la biblioteca se viese la
necesidad de instalar Linux (Sistema GNU) como sistema compartido para poder
correr todas las herramientas que se usaban (Herramientas GNU) en vez de en
XP. Se debe mencionar que aunque las herramientas usadas en el marco de este
proyecto son multiplataforma, lógicamente existe más documentación y ayuda
para usuarios de sistemas GNU, que para usuarios de MS (“el enemigo”). Gracias
a innumerables pruebas se consiguió que funcionase. Por este engorroso trabajo
y con vistas a agilizar el proceso para futuros desarrolladores, se explica como
hacerlo en el Apartado 1.4.2. Esto no solo vale para “GMP+Qt+MS” sino para
cualquier biblioteca del proyecto GNU, es decir, sirve para hacer uso de
bibliotecas libres en plataformas Windows junto con Qt o similar.
La librería GMP posibilitó, a parte del trabajo con números
desproporcionados, aumentar la velocidad en algunos procesos, en su mayoría
asimétricos. Para el caso de uso del algoritmo de Euclides optimizado, el cual en
principio era bastante rápido para el cálculo del máximo común divisor, nos vimos
14

Es un tipo de archivo para indicar las cabeceras (definiciones de clases), las fuentes (código implementado
de la clase), otras fuentes (imágenes, bases de datos… de las que se surten las clases) y las librerías usadas,
todo de cara a la creación de la aplicación.

-26-


obligados a sustituirlo por la función correspondiente proporcionada por GMP. Se
comprobó que la velocidad de ejecución de la función de GMP era 3/2 veces más
rápida que el algoritmo de Euclides utilizado (en un entorno de variables GMP). A
su vez, el cálculo del inverso para la obtención de la clave privada de RSA fue
cambiada. Con estas dos adaptaciones, se mejoró el tiempo de proceso en los
algoritmos de RSA dedicados a la generación de claves.
Los algoritmos dedicados al encriptado y desencriptado de RSA, también
sufrieron las mejoras proporcionadas por GMP. En primer lugar se optó por
ejecutar con la función correspondiente GMP el proceso de elevar el mensaje a la
clave y luego calcular el módulo. De esta forma comprobaríamos los márgenes
que permite esta librería, pero al igual que se explicó con el Cuadro de Código
1.2, esto no fue posible porque se debe ir haciendo el módulo y no dejarlo para el
final. Por ello se hizo uso de una función para el cálculo exponencial que
incorporase los módulos sucesivos.
Incorporadas estas mejoras, se quitó el límite existente para la elección de
primos, se usó una nueva función para su cálculo y se incorporaron márgenes
dinámicos para las elecciones de listas. El hecho de introducir todas las
posibilidades numéricas existentes, requiere muchos recursos. Sabemos que
reconocer si un número elevado es primo, es lento. Reconocer cuantos números
primos existen en una lista fijada en cero y con un máximo, es exponencialmente
más lento cuanto mayor es ese máximo. Es por eso que si el margen inferior junto
con el superior, se hacen dinámicos, se podría centrar el área de trabajo donde
sea más apetecible para la elección del número, sin necesidad de tener que
aumentar el listado por el simple hecho de buscar un primo de mayores
dimensiones. Aparte, para los casos de seleccionar márgenes reducidos, la
elección sería más rápida. El único problema que trae la implementación de un
margen dinámico, como este, con un límite superior y un límite inferior, es que a
priori no se saben las distancias entre primos. Un mismo margen centrado en un
rango de números pequeños podría dar “x” números primos, y si se centrase en
un rango de números más elevados daría “y” números primos, siendo “y<x” o
incluso ninguno. Es por este comportamiento (percibido en la ejecución), que se
propinó el uso de un límite inferior a partir del cual contar un número “n” de primos
para introducirlos en la lista de elección de usuario. Este algoritmo anterior
también fue reutilizado para el cálculo de la clave privada E en RSA.
Esta última liberación facilita al usuario la posibilidad de seleccionar
cantidades ingentes de texto con claves indefinidamente largas. El uso de GMP
que hacemos con Qt esta sujeto a unos limites. Así se definieron en base a una
serie de tests en ejecución unos máximos definidos para evitar sobrecargas. En
función del mensaje para DES y en función del mensaje y las claves para RSA.
Es con esta fase con la que se da por concluida la realización del software.
Para las nuevas ideas que surgieron y que serian interesantes llevar a cabo
véanse las Líneas Futuras de desarrollo en el Capítulo 4.

1.4.- Configuración del sistema.
Este apartado, dedicado a la configuración del sistema, proporciona los
-27-


pasos necesarios para que el lector pueda configurar su equipo y trabajar con
C/C++ y cualquier librería GNU15. Para la configuración es necesario tener
conexión a Internet

1.4.1.- Linux.
La configuración del sistema para Linux, a parte de ser mínima, presenta
mayor y mejor documentación al respecto, al tratarse del uso de sus propias
librerías, puesto que este sistema operativo se encuentra dentro del proyecto
GNU. No obstante explicamos los pasos a seguir para configurar Linux.
Abrimos el gestor de paquetes16 (Menú Sistema/ Administración/ Gestor de
Paquetes – Synaptic). Buscamos Qt [B.R.2.11] y cargamos. Si no se encuentra la
última versión es debido a que tenemos configurado el SO como “estable”17,
habría que cambiarlo a “inestable” y repetir la búsqueda. El gestor de paquete se
encargará automáticamente de encontrar la versión para el sistema, de compilar e
instalar.
Para el caso de GMP [B.R.2.14] o cualquier otra librería que se requiera, se
hace exactamente igual, mediante el gestor de paquetes.
Una vez se dispongan de las librerías necesarias y con el supuesto
conocimiento sobre C/C++ [B.R.2.4], se escribe el código en el bloc de notas del
sistema o preferido. El archivo principal tiene que llamarse “main”.
Es necesario el compilador GCC [B.R.2.16]. Este suele venir instalado con
el sistema, pero sino volvemos al gestor de descargas.
Terminado el proyecto (código), nos situamos en un terminal de consola,
en la ruta de la carpeta de trabajo y escribimos: “qmake -project”, para crear un
proyecto Qt, “qmake”, para configurar los archivos que hacen uso de Qt antes de
la compilación y al final “make” para compilar. Si no ha habido errores, se creara
una carpeta con el ejecutable del proyecto.

1.4.2.- Windows XP.
La configuración del sistema para Windows, no es inmediata y presenta
escasa documentación al respecto. Es por ello que se facilitan los pasos a seguir
detalladamente, para el que fue en un 99% el entorno de trabajo durante todo el
proyecto.
Al no disponer de un gestor de paquetes como el de Linux, es necesario
descargarlo. Escribimos en la barra de direcciones,
http://trolltech.com/downloads/opensource, aquí podemos observar en el recuadro

15

La librería usada tiene que soportar el lenguaje de programación.
El gestor de paquetes del sistema GNU, se encarga de tener actualizado tanto el sistema como el resto de
software instalado. También permite la búsqueda e incorporación de nuevos softwares, ya se libre o no.
17
La configuración estable limita las últimas versiones del software libre hasta que no están liberadas como
estables por GNU.
16

-28-


“Qt Open Source Edition for C++ Developers”, el enlace para bajarnos Qt según
el sistema poseído. También existe la alternativa no automática del gestor de
paquetes para Linux (X11). Pulsando sobre plataformas Windows, se nos
presenta una ventana con multitud de enlaces de descargas por zonas.
Independientemente de la zona, pulsamos sobre la que hace referencia a MinGW,
es decir, el auto instalable (qt-win-opensource-X.X.X-mingw.exe). Se iniciará la
descarga de Qt. Trolltech proporciona tanto los paquetes como un ejecutable.
Siempre que dispongamos del “install” lo utilizaremos, pues su uso es más fácil.
Para la instalación, seguimos detenidamente todos los pasos y cuando pregunte
si deseamos descargar MinGW afirmamos.
Qt proporciona un terminal para crear y compilar sus proyectos. Con la
ayuda de un bloc de notas, una vez terminado el proyecto seguiremos los mismos
pasos que en Linux, pero desde la consola de Qt. Ejecutaremos “qmake -project”,
“qmake”, “make” y listo.
Si se desea usar una versión diferente para MinGW [B.R.2.7], por ejemplo
entre las enlazadas en http://www.mingw.org/download.shtml, es necesario
indicarle a Qt cuando se este instalando, la carpeta raíz donde se encuentra
MinGW.
Caso de habernos bajado los paquetes de Qt (los archivos fuente),
necesitaremos compilarlos para Windows, es decir, tenemos que hacer, lo que el
gestor de paquetes de Linux hacía automáticamente con el código fuente.
Descargamos MSYS [B.R.2.8] desde el enlace del párrafo anterior. Este
proporcionará un entorno similar al de Linux. Una vez instalado, abriendo el
terminal de MSYS, nos situamos en la carpeta donde están las fuentes de Qt y
escribimos “make”, “make install”. Hecha la compilación, para crear los proyectos
solo tendremos que usar el terminal de MSYS de la misma forma que se usa el de
Qt.
A la hora de la ejecución del proyecto Qt, tendremos el inconveniente de
que no podremos acceder fuera del terminal de Qt o MSYS, debido a que estos
son los únicos en incluir en su “Path”18, la ruta de los comandos de la librería (lo
hacen automáticamente con el “make install”). Al desarrollador le interesaría que
en Windows, al igual que en Linux, se tuviese acceso al programa desde
cualquier parte. Para ello, necesitamos incluir las rutas dentro del “Path” de
Windows. Pulsamos “Mi PC” con el botón derecho/ Propiedades/ Opciones
Avanzadas/ Variables de Entorno/ Variables del Sistema/ Path/ Modificar y
añadimos en “Valor de la variable” las rutas necesarias separadas por “;”, lo que
en nuestro caso sería: C:MINGWBIN;C:QT4.3.2BIN;. Aceptando, podremos
acceder al compilador y a los proyectos de Qt, desde cualquier parte del sistema
operativo. Para ejecutar el programa en un sistema donde no se haya instalado
Qt, será necesario pasar las DLLs19 de Qt para el sistema junto con el ejecutable.
Supongamos que una vez configurado Qt, deseáramos trabajar con
algunas librerías de GNU, como por ejemplo GMP. Haciendo uso de MSYS
18

Variable que contiene las rutas donde se encuentran los comandos.
Significa biblioteca de enlace dinámico y es el término con el que se refiere a los archivos con código
ejecutable que se cargan bajo demanda del programa por parte del sistema operativo. Este archivo contiene
funciones que se pueden llamar desde aplicaciones u otras Dll. Los desarrolladores utilizan las Dll para poder
reciclar el código y aislar las diferentes tareas.
19

-29-


ejecutaríamos “make” y “make install” en la carpeta donde hayamos
descomprimido los archivos fuente de GMP. Esto nos creará las librerías para
Windows “libgmp.a” y “libgmpxx.a”, y los archivos de cabecera “gmp.h” y
“gmpxx.h”, C y C++ respectivamente. Ambos tendríamos que incluirlos dentro de
la carpeta MinGW, concretamente en MinGW/lib las librerías y en MinGW/include
las cabeceras. A su vez las librerías que se incluyan dentro del proyecto Qt deben
tener su ruta de acceso especificada, dentro del archivo con nombre de proyecto
y extensión “pro” creado por “qmake”.
LIBS +=c:/MinGW/lib/libgmpxx.a. Hay que tener en cuenta que “proyecto.pro” se
genera cada vez que se ejecute “qmake”, por lo que se deberá revisar las librerías
incluidas.

1.4.3.- Mac OS.
La configuración del sistema para Mac, es similar a la de Windows. Pero al
no disponer de la computadora no se pudo correr Qt+GMP en un sistema Mac.
Al igual que con Windows, escribimos en la barra de direcciones,
http://trolltech.com/downloads/opensource, aquí podemos observar en “Qt Open
Source Edition for C++ Developers”, el enlace para bajarnos Qt para Mac.
Pulsando sobre la opción de esta plataforma, nos descargamos la versión de
paquetes, pues no dispone de un auto instalable. Una vez compilada la librería Qt
y todas las necesarias, usando GCC adaptado para MAC, actualizamos el “Path”
del sistema. Con esto se estaría en disposición para trabajar con Qt+GMP.
Los detalles de creación de proyectos son los mismos que en los sistemas
anteriores.
También es posible configuran una IDE [B.R.2.5-2.6] en los tres sistemas,
usando el compilador que adapta GCC al entorno en cada caso y referenciando
las librerías. Sin embargo sería necesario un terminal u otro acceso para ejecutar
“qmake -project” y “qmake”.

1.5.- Relación entre clases.
El fruto de las fases de trabajo fueron una serie de clases. El uso adecuado
sus objetos, la estructuración del conjunto y las comunicaciones entre los distintos
niveles, permiten la correcta ejecución del software, así como la integración de
nuevos métodos y objetos. En el presente apartado se pretende explicar la
jerarquía y comunicación entre las clases con ayuda de la Figura 1.8. En esta
figura se muestran los tipos de archivo, sus números de líneas de
implementación, sus relaciones por colores y los niveles de comunicación que
poseen. Existen 6 niveles de comunicación entre clases, de 0 a 5.
A través del Nivel 0, se le pasa a “main”, archivo principal, un objeto de la clase
“miproject”, clase principal para mostrar la aplicación y hacia abajo se pasan a
todas las clases los archivos exteriores que se utilizan (en su mayoría de tipo
imagen).
-30-


El Nivel 1, comunica los criptosistemas con la clase principal (la interfaz).
La clase “micriptosistema” indica a “miproject” cuando esta lista para que se
proceda según sea el caso. Con la interfaz se pasa el algoritmo deseado y si se
quiere encriptar o desencriptar. Cuando “micripstosistema” este lista enviará la
señal para realizar y mostrar operación. En el caso de haber usado RSA, por si
solo o mediante el protocolo Digital, “micriptosistema” hará un registro de claves
que pasará a “miproject”, donde se guardará en un registro y/o archivo.
Con el Nivel 2 se desarrollan todas las comunicaciones entre los
criptosistemas y las gestiones de claves. Es únicamente en este nivel, donde se
realizan los cifrados y descifrados, para que después “micriptosistema” se
encargue de pasarlos a “miproject” y este los muestre. Se pueden distinguir 3
partes dentro de este nivel claramente diferenciadas: el uso del criptosistema RSA
con su correspondiente gestión de claves, el uso de los criptosistemas DES y
TDES con la misma gestión de claves para ambos y la parte de gestión de claves
del protocolo RSA Digital (el cual esta implementado dentro de “micriptosistema”).
La parte del Nivel 2 para la gestión de claves, pasará a “micriptosistema” las
claves necesarias obtenidas mediante generación, teclado o archivo para el caso
RSA; o de teclado o archivo para el resto de criptositemas. La clase
“micriptosistema” se encargará de hacer las llamadas pertinentes a los algoritmos
criptográficos para realizar las operaciones.
El Nivel 3 para el caso de DES, TDES y RSA Digital comunica con la
última clase de la jerarquía de estos, es decir, con aquella que da la clave privada.
Para el caso de RSA, el Nivel 3 pasará las claves necesarias, evitando la privada
en caso de encriptado.
Los siguientes niveles solo se presentan para el caso de RSA. Estos son
derivados del uso que este criptosistema hace de claves distintas para el cifrado y
descifrado. El Nivel 4 obtiene las claves a través de un archivo o por entrada de
teclado. Para terminar, el Nivel 5, es el equivalente al Nivel 3 para el caso de
DES, TDES y RSA Digital, es decir, comunica con la última clase de la jerarquía
de gestión de claves RSA y devuelve la clave privada.
Los posibles caminos de transito que se han comentado para los
criptosistemas y el protocolo, se muestran en la Figura 1.9, véase conjuntamente
con la Figura 1.8.
Vistas las interconexiones de las clases implementadas y con el
conocimiento adquirido en esta introducción sobre el trabajo desarrollado, se
continúa con el siguiente capítulo, donde confluirán teoría y código de los
criptosistemas desarrollados20.

20

Toda las veces que se refiera a criptosistemas desarrollados como conjunto de las posibilidades
criptograficas de CriptoYenet se esta incluyendo a RSAD aunque este sea un protocolo.

-31-

CRIPTOSISTEMAS

Interfaz Principal
14

30

68

81

488

mirsa
44

123

69

Nivel 0

520

miproject

522

mides

main

Nivel 1

mitdes

81

miparametro
130

612

micriptosistema

Nivel 2
55

103

mimargen

Gestión RSA

65

Gestión DES-TDES

144

53

103

Gestión RSAD

midefinirointeriordes

migenecargosesirsa

59

146

midesotdes

Nivel 3

80

304

56

migenerarrsa

115

mimanualoarchivorsa

59

158

miusarsesionrsa

50

105

micprivadades

Nivel 4

55

113

56

mimanualrsa

166

miarchivocpsrsa

45

83

micprivadarsa

49

107

micprivadadesrsad

Nivel 5

Figura 1.8: Relación entre las clases implementadas

44

130

miarchivocprivadarsad


Elección de
DES en
“miproject”
Elección de
TDES en
“miproject”
Elección de
RSAD en
“miproject”

Nivel 1

Nivel 2

Nivel 3

Nivel 4

Nivel 1

Nivel 2

Nivel 3

Nivel 4

Nivel 1

Nivel 2

Nivel 3

Nivel 5

Nivel 1

Elección de
RSA en
“miproject”

Nivel 2

Nivel 3

Nivel 1

Nivel 2

Nivel 3

Nivel 1

Nivel 2

Nivel 1

Nivel 2

Nivel 1

Nivel 2

Nivel 1

Nivel 2

Nivel 5

Nivel 3

Nivel 3

Posibilidades
RSA

Figura 1.9: Caminos posibles para las comunicaciones de los criptosistemas y el protocolo.

-33-

CAPÍTULO 2
-Algoritmos Criptográficos Desarrollados-

Proyecto Fin de Carrera

Capítulo 2: Algoritmos Criptográficos Desarrollados

CAPÍTULO 2 - Algoritmos Criptográficos
Desarrollados.
Por sus ventajas y alcances, se empezó con la implementación de RSA y
DES, para después a partir de ellos desarrollar TDES y RSAD. Criptosistemas y
protocolo que son detallados en su implementación para el cifrado y descifrado,
así como para su generación de claves, en los siguientes apartados. La parte
correspondiente a la explicación de la gestión que se hizo de sus claves, se
reserva para el final del capítulo.

2.1.- RSA.
2.1.1.- Introducción.
Como ya se ha comentado brevemente en las Fases de Trabajo, el RSA es
un algoritmo asimétrico cifrador de bloques, que utiliza una clave pública, la cual
se distribuye (en forma autenticada preferentemente), y otra privada, la cual es
guardada en secreto por su propietario [B.R.1.1 y B.R.1.29-1.31]. Este sistema fue
desarrollado por Ronald Rivest, Adi Shamir, y Leonard Adleman, cuando eran
estudiantes en la MIT. Su esquema es bastante simple (Figura 2.1). El transmisor
o una red pública, disponen de las claves públicas con las que se cifra el mensaje.
El mensaje cifrado “c” se transmite al receptor. Este por medio de la red pública
obtiene la parte de la clave pública y la usa junto con su clave privada para
descifraran “c”, obteniendo el mensaje original “m”.

Figura 2.1: Sistema RSA

La clave pública esta formado por un par: “n” y “e”. Utilizadas para el cifrado. La
clave privada es “d” y se utiliza para el descifrado junto con la clave pública “n”.

-37-


2.1.2 Generación de claves.
La generación de claves del algoritmo RSA, tuvo su primera
implementación en las fases del comienzo de lo que sería CriptoYenet. Sus
bases se sustentan en una función especial denominada función φ (n ) . Función
generadora de claves definida por la multiplicación de dos números primos
elevados, a los que se les sustrae la unidad. Dicha expresión viene dada por:

φ (n ) = ( p − 1)(q − 1) , siendo p ≠ q

(2.1)

La dinámica de esta generación, se inicializa escogiendo dos números
primos muy elevados (cuanto mayores sean más seguro será el sistema) de
forma que sean distintos entre si. El modo en el que se ha implementado la
elección de cada uno de ellos se puede ver en el Cuadro de Código 2.1, donde se
muestra el ejemplo concreto para el cálculo de “p”. Para el caso del primo “q”, el
proceso es el mismo, únicamente se quita “p” de la lista de los primos a elegir.

void MiGenerarRSA::elegirP(){
QStringList listaPrimosCarP;//lista de números primos almacenada como carácter
dLimitesLista->vaciar();//para los limites de la lista
dLimitesLista->ponerNombre(tr("Seleccione los parámetros para buscar los primos"));
mpz_class minList=1000;//valor por defecto para el comienzo de búsqueda
mpz_class cantidad=10;//valor por defecto para la cantidad de primos dados de encontrar
dLimitesLista->setInferior(QString::fromStdString(minList.get_str(10)));
dLimitesLista->setCantidad(QString::fromStdString(cantidad.get_str(10)));
dLimitesLista->exec();//debemos seleccionar los parámetros de búsqueda
if(dLimitesLista->getReady()){//si se aceptó continuamos
minList=dLimitesLista->getInferior();
cantidad=dLimitesLista->getCantidad();
mpz_class i=0;
while(i<cantidad){//vamos a calcular la cantidad de números primos
mpz_nextprime(minList.get_mpz_t(), minList.get_mpz_t());
listaPrimosCarP.append(QString::fromStdString(minList.get_str(10)));//lo almacenamos
i=i+1;//aumentamos la cantidad
}
dParametroEnRSA->vaciar();
dParametroEnRSA->ponerNombre(tr("Elija un número primo de la lista P"));
dParametroEnRSA->ponerLista(listaPrimosCarP);
dParametroEnRSA->exec();
if(dParametroEnRSA->listo()){
//Guardamos QString como mpz_class
rsa->p.set_str(dParametroEnRSA->extraer().toAscii().data(),10);
labelP->setText(dParametroEnRSA->extraer());//ponemos el texto en labelP
botonP->setEnabled(false);//desactivamos este paso
botonQ->setEnabled(true);//activamos el siguiente paso
}
}
}
Cuadro de Código 2.1: Cálculo de la lista de números primos

-38-

Aplicación software para el desarrollo de tareas criptográficas

Aplicación software para el desarrollo de tareas criptográficas

Recommandé

Recommandé

Contenu connexe

Similaire à Aplicación software para el desarrollo de tareas criptográficas

Similaire à Aplicación software para el desarrollo de tareas criptográficas (20)

Dernier

Dernier (20)

Aplicación software para el desarrollo de tareas criptográficas