BANCO DE PRUEBAS PARA ALGORITMOS DE CRIPTOGRAFÍA … · Los algoritmos se añadirán al programa...

- 0

1.

PROYECTO FIN DE CARRERA

BANCO DE PRUEBAS PARA

ALGORITMOS DE CRIPTOGRAFÍA

GRÁFICA

AUTORA: Susana López Lumbierres

MADRID, Septiembre 2006

UNIVERSIDAD PONTIFICIA COMILLAS ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA (ICAI)

INGENIERO EN INFORMÁTICA

1

Autorizada la entrega del proyecto al alumno:

Susana López Lumbierres

EL DIRECTOR DEL PROYECTO

Gonzalo Álvarez Marañón

Fdo: Fecha:

Vº Bº del Coordinador de Proyectos

Miguel Ángel Sanz Bobi

Fdo: Fecha:

- I

RESUMEN

La criptografía gráfica tiene como objetivo el diseño, desarrollo e

implementación de criptosistemas para el cifrado/descifrado de imágenes

digitalizadas, así como de protocolos orientados al reparto de imágenes secretas,

entre otros.

Los procesos de cifrado/descifrado permiten hacer ilegible el

contenido de una imagen para cualquiera que no esté autorizado a conocer su

contenido; mientras que los esquemas para compartir imágenes secretas permiten

repartir una imagen entre varios participantes de modo que sólo determinados

subconjuntos de participantes cualificados pueden recuperar la imagen secreta

original.

Actualmente existe un vacío de herramientas integradas para el estudio

y análisis de la seguridad de algoritmos de criptografía gráfica. Este proyecto,

Banco de Pruebas para Algoritmos de Criptografía con Imágenes (BPACI),

pretende llenar este vacío mediante su entorno integrado de manipulación de

imágenes con la novedosa posibilidad de añadir algoritmos criptográficos en la

forma de plug-ins escritos en cualquier lenguaje de programación orientado a

objetos. De esta manera, se separa la labor criptográfica de crear los algoritmos de

la labor criptoanalítica de evaluar su seguridad.

El objetivo general de BPACI es contribuir al estudio de la seguridad

de los algoritmos de criptografía gráfica.

II

Para ello, los objetivos que este proyecto debe cumplir son:

- Desarrollo de un entorno integrado para la manipulación de

imágenes

- Definición de interfaces de relación con plug-ins criptográficos en

los que se programe los algoritmos de cifrado o reparto secreto para imágenes.

- Desarrollo de tests de análisis de seguridad de algoritmos de

criptografía gráfica.

- Desarrollo de diversas herramientas de ayuda al cifrado o al

estudio de la seguridad.

El resultado de este proyecto es que, a partir de unas plantillas

diseñadas, cualquier persona sin necesidad de tener grandes conocimientos de

informática (bastará con saber programar el algoritmo), podrá procesar imágenes

digitalmente con los algoritmos que él haya implementado.

Los algoritmos se añadirán al programa como archivos DLLs. El

motivo de usar este tipo de archivos en el proyecto, es que se pretende que

personas ajenas a esta aplicación puedan utilizarla para fines de criptografía

gráfica, es decir, que la aplicación se adapte a las necesidades de cada uno, sin

necesidad de retocar el código propio de BPACI. Esto es posible ya que al

desarrollar una DLL se tratará como archivo independiente, pudiendo añadir o

eliminar archivos, funciones internas a estas DLLs sin necesidad de volver a

compilar y ejecutar BPACI siempre y cuando que se respeten las plantillas

diseñadas

III

SUMMARY

The aim of graphical cryptography is the design, the development ant

the implementation of cryptosystems for coding and decoding digitalized images,

as well as protocols for the sharing of secret images.

Both processes, code and decode, allow to make the content of an

illegible image for any person who is not authorized to know its content; whereas

the schemes for share secret images allow to distribute an image among several

participants so that only certain subsets of qualified participants can recover the

secret original image.

Nowadays there exists an emptiness of integrated tools for the study

and analysis of the safety of algorithms of graphical cryptography. This project, “

TESTING BENCH FOR ALGORITHMS OF GRAPHICAL CRYPTOGRAPHY

” , (BPACI), tries to fill this emptiness through its integrated environment of

manipulation of images with the new possibility of adding algorithms as plug-ins

written in any language of programming orientated to objects. This way, the work

of developing algorithms is separated from the work of evaluating the safety of

the algorithms.

The main aim or BPACI is to contribute to the study of the study of

the safety of the algorithms of graphical cryptography.

So, the aims that this project must fulfil are:

- Development of an environment integrated for the manipulation of

images.

IV

- Define interfaces to connect with plug-ins of cryptography where

algorithms of coding have been programmed.

- Development of tests to analyse the security of the algorithms of

graphical cryptography.

- Development of some tools of help to the coding or the study of the

safety.

Beginning from some patterns developed, any person without great

knowledge of computer science, (it will be enough to be able to programme the

algorithm), will be able to process images digitally with the algorithm that he has

implemented.

The algorithms will be added to the application as DLL files. The

reason to use this kind of files to the project is due to the fact that there is claimed

that foreign people can use this application to graphical cryptography purposes. It

means, the application has to adapt to the needs of users, without the need to

rewrite the code of BPACI. This is possible because of the files DLL; they will be

treated as independent files, so we can add or remove files, and also retouch

internal function from them without compiling and executing the project. All of

this, it is possible, as long as the patterns developed are respected.

ÍNDICE

1. INTRODUCCIÓN ……………………………………………. 5

2. DEFINICIÓN DEL PROBLEMA Y OBJETIVOS …………... 6

3. ANÁLISIS DE REQUISITOS ………………………………... 8

3.1 Menú Archivo ………………………………………….. 10

3.2 Menú Edición …………………………………………... 13

3.3 Menú Ver ………………………………………………. 14

3.4 Menú Ayuda ……………………………………………. 16

3.5 Menú Ventana ………………………………………….. 17

3.6 Menú Colores …………………………………………... 18

3.7 Menú Tests ……………………………………………... 19

3.8. Menú Utilidades ………………………………………... 20

3.9 Menú criptografía ………………………………………. 21

3.10 Gestión de excepciones ………………………………... 23

4. ARQUITECTURA DEL SISTEMA. ………………………... 25

5. DISEÑO DE BAJO NIVEL …………………………………. 28

5.1 Diagramas de Flujos de Datos ….………………………….. 29

5.1.1 Diagrama de contexto …………………………. 29

5.1.2 Diagrama de primer nivel ……………………... 31

5.1.3 Diagrama Menú Archivo ……………………… 33

5.1.3.1 Diagrama Abrir ………………………... 35

5.1.3.2 Diagrama Guardar como ……………… 37

5.1.4 Diagrama Menú Edición ………………………. 39

5.1.5 Diagrama Menú Ver …………………………... 41

5.1.6 Diagrama Menú Criptografía ………………….. 43

5.1.6.1 Diagrama Aplicar Algoritmo ………….. 45

5.1.7 Diagrama Menú Colores ………………………. 47

5.1.8 Diagrama Menú Utilidades ……………………. 49

5.1.9 Diagrama Menú Ventana ……………………… 51

5.1.10 Diagrama Menú Tests ………………………… 53

6. PROGRAMACIÓN …………………………………………. 55

7. PRUEBAS DEL SISTEMA ……………………………...….. 56

7.1 Tipos de pruebas ………………………………………... 57

8. ACCESO A LOS ALGORITMOS DE CRIPTOGRAFÍA

CON IMÁGENES ……………..………………………………. 58

9. LIBRERÍAS DE ENLACE DINÁMICO ………………….... 64

10. PLANTILLAS PARA LAS DLLS ………………………… 66

11. OTRAS PLANTILLAS ……………………………………. 69

12. COMPILACIÓN DE LAS DLLs ……………………...…… 70

13. REQUISITOS HARDWARE ……………………...………. 77

14. INSTALACIÓN …………………………………………..... 80

15. CONCLUSIONES ………………………………………..... 85

15.1 Aportaciones …………………………………………... 85

15.2 Sugerencias de trabajo futuro ………………………….. 87

16. PLANIFICACIÓN DEL PROYECTO …………………...... 88

16.1 Definición de tareas …………………………………… 88

16.2 Dependencia entre tareas ……………………………… 89

16.3 Recursos ……………………………………………….. 90

16.4 Planificación …………………………………………... 90

17. PRESUPUESTO DEL PROYECTO ……………………… 91

18. BIBLIOGRAFÍA …………………………………………... 92

ANEXOS ………………………………………………………. 93

ANEXO A. Plantillas para DLLs ………………………………. 94

ANEXO B. Otras plantillas …………………………………… 113

ANEXO C. Manual de usuario ……………………………….. 116

Banco de Pruebas para Algoritmos de Criptografía con Imágenes

Susana López Lumbierres Página 5

1.- INTRODUCCIÓN

La criptografía gráfica tiene como objeto el diseño, desarrollo e

implementación de criptosistemas para el cifrado/descifrado de imágenes

digitalizadas, así como de protocolos orientados al reparto de imágenes secretas,

entre otros.

Los procesos de cifrado/descifrado permiten hacer ilegible el

contenido de una imagen para cualquiera que no esté autorizado a conocer su

contenido; mientras que los esquemas para compartir imágenes secretas permiten

repartir una imagen entre varios participantes de modo que sólo determinados

subconjuntos de participantes cualificados pueden recuperar la imagen secreta

original.



2. DEFINICIÓN DEL PROBLEMA Y

OBJETIVOS

Actualmente existe un vacío de herramientas integradas para el estudio

y análisis de la seguridad de algoritmos de criptografía gráfica.

Este proyecto, Banco de Pruebas para Algoritmos de Criptografía con

Imágenes (BPACI), pretende llenar este vacío mediante su entorno integrado de

manipulación de imágenes con la novedosa posibilidad de añadir algoritmos

criptográficos en la forma de plug-ins escritos en cualquier lenguaje de

programación orientado a objetos. De esta manera, se separa la labor criptográfica

de crear los algoritmos de la labor criptoanalítica de evaluar su seguridad.

El objetivo general de BPACI es contribuir al estudio de la seguridad

de los algoritmos de criptografía gráfica.

Para ello, los objetivos que este proyecto debe cumplir son:

- Desarrollo de un entorno integrado para la manipulación de

imágenes



Este proyecto debe ser una aplicación consistente y completa

por sí misma y deberá tener todo aquellos recursos que necesite para su

ejecución.

- Definición de interfaces de relación con plug-ins criptográficos

en los que se programe los algoritmos de cifrado o reparto secreto para

imágenes.

Se van a desarrollar interfaces con bibliotecas dinámicas de

manera que el entorno pueda cargar distintos algoritmos a los que se les

proporciones imágenes y de los que reciba las imágenes procesadas.

- Desarrollo de tests de análisis de seguridad de algoritmos de

criptografía gráfica.

- Desarrollo de diversas herramientas de ayuda al cifrado o al

estudio de la seguridad.

Utilidades adicionales que le hemos dado a la aplicación, como

por ejemplo, la posibilidad de generar claves pseudos-aleatorioas o

funcionalidades de manipulación de imágenes, como zoom, información sobre

un píxel o cambio de color de píxeles.



3.- ANÁLISIS DE REQUISITOS

Con este proyecto se pretende ofrecer al usuario una aplicación

independiente para su uso particular, y que cumpla con los objetivos detallados

anteriormente, incluida la novedad de poder interactuar con algoritmos

programados independientemente al proyecto.

Además de conseguir una aplicación para el uso de algoritmos de

criptografía no debemos olvidar el aspecto gráfico que debe contener ests

aplicación para que podamos tratar las imágenes antes y después de ser

procesadas.

En esta fase, además de conseguir un conocimiento suficiente del

sistema, se ha especificado también de qué manera se han resuelto dichos

requisitos.

La organización de esta etapa, está siguiendo la ventana principal de la

aplicación, que se muestra en el manual de usuario en el Anexo C.



Los principales requisitos funcionales que debe cumplir este proyecto

son los siguientes:

- Formatos de archivo de entrada: bmp, gif, tiff, jpg, texto.

- Formatos de archivo de salida: bmp, gif, tiff, jpg, texto.

- Configuración en archivo xml

- Información de la imagen: color, ancho, altura, nivel de zoom,

fecha..

- Panelado de imágenes: en cascada, ordenado horizontalmente y

verticalmente.

- Zooming

- Pincel de color

- Instalable

- Gestión de excepciones: mensajes de usuarios descriptivos, log en

sucesos del sistema.

- Generación de claves pseudos aleatorias

Estos requisitos se han organizado en forma de menú y submenús en la

ventana principal junto a otras funcionalidades que se especifican en la figura 1 y

se detallan a continuación.



Figura 1: Funcionalidades de BPACI

3.1 Menú Archivo

Submenús: Nuevo, Abrir, Guardar, Guardar como.., Propiedades, Salir

Opción de abrir y guardar imágenes en los formatos de archivo

más utilizados: bmp, gif, tiff, jpg, texto.

Nuevo Abrir Guardar

Propiedades Salir

Archivo Edición

CortarCopiar Pegar Voltear Horizontalmente Girar 180º

Ver

Barra de estado Barra de herramientas Imagen completa Imagen real Procesar Zoom

Ventana

CascadaOrdenar horizontal Ordenar vertical

Ayuda

Acerca de..

Colores

Modificar color pixel Datos pixel

Utilidades

Generar

Tests

HistogramaCorrelación Todos los tests

BPACI

Criptografía

Añadir algoritmo [Algoritmos añadidos]



Al guardar una imagen como texto, obtendremos todos los valores

numéricos de los píxeles. Al abrir este archivo .txt el resultado se mostrará

en pantalla en forma de imagen.

Para conseguir guardar una imagen como texto, lo primero que se

hace es leer los bytes de la imagen abierta con BinaryReader y

almacenarlos en un array de bytes del mismo tamaño que el fichero.

Hay que tener en cuenta que una foto es una matriz con sus

columnas y filas. Al guardar los datos en formato texto debemos respetar el

final de cada fila de la imagen, que no tiene por qué corresponder con el

final de una línea del archivo de texto. Al llegar a estos puntos, en el archivo

texto se produce un salto de línea. Además el valor de cada píxel se separa

de los adyacentes con un espacio en blanco.

Un ejemplo de lo explicado se muestra en la siguiente figura.



Figura 2: Imagen guardada como archivo de texto

En este menú archivo también podemos obtener la información de

una imagen abierta. Estas propiedades serán información sobre la imagen

abierta, como su ubicación, tamaño, numero de bits por píxel,.. Además

también tenemos la opción de poder obtener metadatos almacenados en este

objeto, como pro ejemplo su fecha.

La opción Salir nos permitirá abandonar la aplicación, y el programa

se cerrará.



3.2 Menú Edición

Submenús: Cortar, Copiar, Pegar, Voltear Horizontalmente, Girar

180º, Voltear Verticalmente

En este menú aparecen las operaciones de cortar, copiar y pegar con

las que podremos exportar imágenes de BPACI a otros programas, y también

importarlas.

Para estas funciones se ha trabajado con la clase Clipboard que

proporciona métodos para colocar los datos en el portapapeles del sistema y

recuperarlos. Estos métodos so:

- SetDataObject que coloca datos en el portapapeles del sistema.

- GetDataObject que recupera los datos actualmente contenidos en el

portapapeles.

Para la función de cortar, una vez que se han copiado los elementos en

el portapapeles, se elimina la función seleccionada en pantalla.

Además con las funciones de Voltear Horizontalmente, Girar 180º y

Voltear verticalmente el usuario podrá encontrar la forma más cómoda de

trabajar con las imágenes en pantalla.

La implementación de estas funciones se ha llevado a cabo a través

de los miembros de la enumeración RotateFlypType del espacio de nombres

System.Drawing. Estos métodos nos permiten elegir la dirección de giro de

una imagen y el eje que se utiliza para voltearla.



3.3 Menú Ver

Submenús: Barra de estado, Barra de herramientas, Imagen

completa, Imagen real, Procesar, Zoom.

Este menú tiene tres zonas diferenciadas y separadas por una línea.

Las dos primeras: barra de estado y barra de herramientas,

permiten al usuario elegir si quieren que en su aplicación aparezca o no

tanto la barra de herramientas, situada arriba de la ventana principal como la

barra de estado que aparece abajo. Cuando estén habilitadas, aparecerá junto

a ellas en el menú un tick de activación. Cuando no estén presentes en la

aplicación, entonces este tick desaparecerá.

La eliminación de estas barras nos puede hacer ganas espacio para la

imagen.

Los dos submenús siguientes: Imagen completa e Imagen real

permiten elegir la forma en que se quiere ver la imagen en pantalla.

Para ello se ha utilizado los miembros de la enumeración

PictureBoxSizeMode del espacio de nombre System.Windows.Forms para

especificar cómo se coloca una imagen dentro de un PictureBox. (Los

PictureBox representan un cuadro de imagen de Windows donde se

muestran las imágenes.)

En un principio, cuando se abre una imagen, esta aparece con

centrada con PictureBoxSizeMode.Normal que coloca la imagen en la

esquina superior izquierda del PictureBox. La imagen se recorta si es más

grande que el PictureBox que la contiene.

Cuando queremos que la imagen aparezca completamente en

pantalla, ya se ajuste al tamaño de ventana que tenemos abierto, se utiliza



PictureBoxSizeMode.StretchImage para que la imagen situada dentro del

PictureBox se estire o encoja para ajustarse al tamaño. Este método

deformaba la imagen al ajustarse a la ventana abierta, para solucionarlo, se

han calculado las dimensiones relativas y se ajustan el ancho y el alto en la

misma proporción.

Para la otra opción del menú, “Imagen real”, se ha utilizado el

método PictureBoxSizeMode.AutoSize que hace que el tamaño de

PictureBox se ajuste al tamaño de la imagen que la contiene.

En la tercera división de este menú tenemos los submenús de

Procesar y Zoom.

La primera “procesar” nos permitirá aplicar filtros verdes, azules o

verdes a la imagen en pantalla, con lo cual ésta cambiará de color.

Con el submenú Zoom tendremos la posibilidad de acercar o alejar la

imagen en pantalla. Utilizando este menú, únicamente podremos acercar la

imagen hasta 11 veces, y lo mismo al alejar.

Sin embargo, con las funcionalidades añadidas en la barra de

herramientas podremos ir acercando o alejando la imagen poco a poco con

los botones “Ampliar zoom” y “Disminuir Zoom”. También, para lograr el

mismo resultado podremos introcir el nivel de zoom en la casilla en blanco y

tras pulsar el botón “Nivel Zoom” obtendremos el resultado en pantalla.

La implementación del zoom es la misma para las tres formas

diferentes de hacer zoom. La principal diferencia es que con las opciones del



submenú, el nivel del zoom viene dado al pulsar el botón, y con el resto hay

que calcular en función del nivel de zoom que tenía la imagen antes de hacer

el nuevo.

En la implementación del zoom, se han encontrado varias

dificultades que se han resuelto de la siguiente forma. Para calcular un

nuevo zoom, hay que conseguir las medidas de la imagen y el nivel de zoom

que tiene en ese momento. Se deben calcular las medidas originales de la

imagen, es decir, las medidas de la imagen cuando no tiene aplicado ningún

nivel de zoom y a partir de estas medidas calcular la nuevas multiplicando

en caso de querer acercar la imagen o alejando en el caso de pretender

disminuirla.

Además, otro problema adicional es que el nivel de zoom viene

indicado en el texto de la imagen abierta, ya que puede ser muy útil saber

con qué nivel de zoom se trabaja en cada instante. Al cambiar el nivel de

zoom, hay que cambiar el valor también del texto de la imagen.

3.4 Menú Ayuda

Submenú: Acerce de..

Un típico acerca de... en el que aparece el nombre completo del

proyecto.

Y el nombre de la autora.



3.5 Menú Ventana

Submenú: Cascada, Ordenar horizontal, Ordenar vertical

En este menú podremos seleccionar la forma en que queremos que se

organicen las imágenes abiertas.

Se ha utilizado MdiLayout del espacio de nombres

System.Windows.Forms para especificar el diseño de las ventanas

secundarias de la interfaz de múltiples documentos (MDI) en una ventana

primaria de MDI. En este proyecto, las ventanas secundarias con las

imágenes que el usuario tenga abiertas, y la ventana primaria en la ventana

principal de BPACI.

Para la organización de las ventanas se han utilizado los siguientes

métodos:

- MdiLayout.Cascade para organizar en cascada todas las imágenes

dentro de la ventana principal.

- MdiLayout.TileHorizontal para organizar en mosaico horizontal

todas las imágenes dentro de la ventana principal.

- MdiLayout.TileVertical para organizar en mosaico vertical todas

las imágenes dentro de la ventana principal.

Esta organización solo será válida para las ventanas que incluyan

imágenes, ya que son las únicas que se han diseñado como MDI de la

ventana principal. El resto de las ventanas que forman parte de esta

aplicación, como la ventana de propiedades, las ventanas de tests,.. no se

podrán organizar de esta forma.



3.6 Menú Colores

Submenús: Modificar color píxel, Datos píxel

Este menú está compuesto por dos submenús, ambos relacionados

con el color de los píxeles.

El primero de ellos “Modificar píxel” nos da la opción de cambiar el

color de un píxel.

Nos aparecerá una ventana donde habrá que indicar las coordenadas

del píxel que queremos cambiar. Una vez escritas las coordenadas, al pulsar

sobre el botón color, nos aparecerá una paleta de colores donde podremos

elegir el color deseado.

Cuando tenemos ya toda la información: imagen a cambiar (se

trabaja con bitmap), coordenadas del píxel(x,y) y color, se aplica el siguiente

método para cambiar el píxel de la imagen a ese color:

bitmap.SetPixel(x,y,Color.FromArgb(cd.Color.R, cd.Color.G, cd.Color.B));

Al activar el segundo submenú “Datos píxel”, se marca a la izquierda

con un tick, despareciendo cuando se desactiva.

Lo que se consigue con esto es que cuando movamos el ratón por

encima de una imagen, nos aparezca en el texto de la imagen, información

del píxel sobre el que se pasa: coordenadas y color.

Para obtener el color de un píxel, el método es parecido al anterior:

GetPixel().



Esta segunda opción puede resultar muy útil, por ejemplo, en el caso

que se quiera cambiar el color de un píxel y no se conozcan sus

coordenadas. Con esta segunda opción activada, pulsando el botón

secundario del ratón, nos aparecerá la pantalla de cambiar color de un píxel,

pero esta vez con los campos de las coordenadas rellenados.

3.7 Menú Tests

Submenús: Histograma, Correlación Vertical, Correlación

Horizontal, Correlación Diagonal, Todos los tests

En este menú podremos obtener los tests que ayudan a evaluar la

seguridad de un algoritmo.

No hay que olvidar que una imagen bien cifrada tendrá los píxeles

repartidos aleatoriamente por todo el cuadro de la imagen

El histograma es un test que calcula el número de píxeles por color.

Por tanto, el histograma de una imagen bien procesada, tiene que ser una

línea horizontal que nos indicará que el reparto de los píxeles es equitativo.

Los tests de correlación, tanto vertical, horizontal, como diagonal

comparan píxeles adyacentes. Así, el test de una imagen bien procesada

debería aproximarse a la diagonal.



La implementación de los cuatro tipo de tests es muy similar. La

diferencia entre unos y otros, son los píxeles que se comparan. En el caso

del histograma, se calcula el color de cada píxel de la imagen, para la

correlación vertical, se compara un píxel con su píxel adyacente en vertical,

en la correlación vertical, igual pero con el píxel adyacente horizontal y en

la correlación diagonal, con el píxel adyacente que esté en diagonal.

Por otro lado, se tienen tres arrays, uno para coordenada RGB, y

cada vez que se calcula un dato, se añade la componente roja al arrayRojo,

la componente verde al arrayVerde y la componente azul al arrayAzul.

Cuando se termina de recorrer la imagen y se han calculado todos los datos,

se representan estos tres arrays simultáneamente y cada uno se pinta con el

color que representa.

3.8 Menú Utilidades

Submenú: Generar clave

En este menú se ha implementado la función de generar una clave

pseudo aleatoria que sirva para loa algoritmos de cifrado y descifrado.

Para la creación de estas claves, la única información que se le

requiere al usuario es la longitud de la clave que desea generar. A partir, de

aquí, el trabajo es del sistema.



Se utiliza la clase RNGCryptoService del espacio de nombres

System.Security.Cryptography que implementa un generador de números

aleatorios (RNG) criptográfico mediante la implementación proporcionada

por el proveedor de servicios criptográficos (CSP).

Para generar esta clave se parte del abecedario hexadecimal, es decir,

“123456789ABCDEF”. Y estos caracteres se van a mezclar aleatoriamente

generando las nuevas claves.

Existe otra función para obtener datos aleatorios que es la función

Random, pero esta posibilidad se descartó ya que es menos eficaz. Random

puede producir el mismo número random en el mismo segundo, y la

posibilidad de que los números random se repitan en mucho mayor.

Cada algoritmo de cifrado y descifrado llevará su propia interfaz

donde se deberá introducir una clave. Esta clave podrá hacerse

manualmente, pero también podemos generarla automáticamente utilizando

este menú.

3.9 Menú Criptografía

Submenú: Añadir Algoritmo, [Algoritmos añadidos]

En el diseño de la aplicación, el único submenú estático es el de

“Añadir Algoritmo”.



Sin embargo, al ejecutar la aplicación aparecerán como submenús

cada uno de los algoritmos compilados como .dll y que están en una

dirección que se ha leído previamente de un archivo config.xml.

Después de leer el directorio donde se encuentran las DLLs, el

sistema accede a ese directorio y lee los archivos que hay, aquellos que

tienen la extensión .DLL son cargados en BPACI, y aparecen como

submenús del menú Criptografía.

Para cargar estos ensamblados a partir de la ruta se utiliza el método

Assembly.LoadFrom (string direccion) del espacio de nombres

System.Reflection

Si estamos utilizando el programa, y queremos añadir un nuevo

algoritmo como DLL para trabajar con ella, entonces podemos utilizar el

único submenú estático de este menú “Añadir Algoritmo”. En este caso nos

aparecerá un cuadro de diálogo donde seleccionaremos el algoritmo

deseado, y automáticamente este algoritmo se añadirá a la lista de submenús

y se habrá hecho una copia en la dirección indicada en el .xml.

De esta forma, no solo lo tenemos disponible esta vez, sino que la

próxima vez que se cargue el programa aparecerá directamente en la lista.

A partir de ahora si pulsamos sobre cualquiera de los nuevos submenús

se procesaran las imágenes abiertas en nuestra aplicación con los algoritmos

implementados en las DLLs que se acaban de cargar.



Cuando se selecciona una de estas DLLs, la aplicación accede a este

archivo, ya que tiene su dirección, y a partir de ahora comienza la búsqueda en

el interior de la DLL para detectar si tiene algún método que BPACI

reconozca, en cuyo caso comenzaría a procesarse el algoritmo de la DLL. Si

se ha cargado una DLL pero no tiene ningún método reconocido por BPACI,

entonces no se ejecuta ninguna acción.

Tanto los pasos detallados para poder trabajar con estas DLLs, y las

plantillas para poder crear algoritmos con los que procesar imágenes desde la

aplicación se explican a lo largo de la memoria.

3.10 Gestión de errores

Existe un archivo llamado Eventos.log que se encuentra en el

directorio BPACI\EventLogs y que contiene información acerca de la ejecución

de la aplicación.

Para cada ejecución del programa se registrará la hora de ejecución, el

directorio del archivo Eventos.log y las DLLs que se cargan dinámicamente al

comienzo de la ejecución.

A lo largo de la ejecución se registrarán algunos errores que puedan

ocurrir. Si en algún momento se desea, se podrán añadir registros a este archivo

teniendo en cuenta que el método utilizado para ello es el siguiente:



private void crearLog(string linea)

{ BPACI.EventLogs.ClaseLog clLog= new BPACI.EventLogs.ClaseLog(linea); clLog.sPathLog = this.sDireccLog; clLog.AñadirLinea(); }

El argumento línea es el mensaje que se desea registrar.



4. ARQUITECTURA DEL SISTEMA

Se trata de una aplicación cliente, es decir, que todos los componentes

necesarios para su ejecución, se instalarán en la máquina del cliente.

La arquitectura está diseñada en dos niveles:

1. Lógica de presentación: donde se han diseñado las diferentes

ventanas del programa y con las que el usuario interactúa directamente.

2. Lógica de negocio: que contiene los algoritmos y la carga

más pesada de programación

Además las DLLs que contienen los algoritmos de criptografía y que

son externas a BPACI, se encuentran agrupadas en una carpeta a la que se accede

para interactuar con ellas. Por tanto, BPACI, no solo cuenta con una interfaz para

relacionarse con el usuario, sino que también consta de otra relación con las

DLLs.

La siguiente Figura 3 muestra estas relaciones.



Figura 3: Arquitectura general

Mediante el nivel de lógica de presentación, el usuario interactuará con

BPACI. En el caso de querer utilizar uno de los algoritmos compilados como

DLLs, seleccionará este mediante la interfaz de usuario (1), y la lógica de negocio

Cliente

LÓGICA DE PRESEN_ TACIÓN

LÓGICA DE NEGOCIO

DLL1

DLL2

DLLN



será la encargada de realizar los procedimientos necesarios para interactuar con la

DLL (2). La DLL mostrará su interfaz, recordemos que cada DLL contiene su

propia interfaz, y el usuario introducirá la clave a utilizar (3). Con los argumentos

pasados desde BPACI, y la clave introducida, se procesará el algoritmo codificado

en la DLL (4), y el resultado se devolverá a la lógica de negocio, que tras analizar

el resultado devuelto (5) lo pasará a la lógica de presentación para que se muestre

al usuario (6).

La explicación gráfica de lo explicado anteriormente, se muestra en la

Figura 4.

Figura 4: Pasos de la arquitectura

LÓGICA DE PRESENTACIÓN

DLLs

LÓGICA DE NEGOCIO

1

6

2

3

4

5



5. DISEÑO DE BAJO NIVEL

En esta fase diseñaremos los diagramas de flujo del sistema.

La técnica de diagramas de flujo de datos (DFD) nos permite una

representación gráfica del sistema para visualizar el sistema desarrollado como

una red de procesos funcionales, y las conexiones entre ellos.

El propósito de un Diagrama de Flujo de Datos es modelar de manera

precisa las funciones que deberá llevar a cabo el sistema y las interacciones entre

ellas. Otro propósito de este es ser leído y comprendido, no sólo por quién lo

construye el modelo sino también por los usuarios que participan.

El diagrama deberá ser fácilmente entendido, fácilmente asimilado y

placentero a la vista.

Para conseguir tales objetivos se han desarrollado varios DFDs en

diferentes niveles.



5.1 DIAGRAMAS DE FLUJO DE DATOS

5.1.1 DIAGRAMA DE CONTEXTO

Representa la vista de más alto nivel de las principales funciones del

sistema, al igual que sus principales interfaces.

Consta de un único proceso que representa el sistema completo. Los

flujos de datos muestran las interfaces entre el sistema y los terminadores

externos. En este caso, el sistema interactúa:

1.- con el usuario,

2.- con las DLLs. Las DLLs no están desarrolladas dentro del sistema,

pero el sistema será capaz de interactuar con ellas, como se verá más en detalle en

los siguientes DFDs.

El usuario podrá enviar imágenes al sistema, que este será capaz de

transformar, calcular propiedades de estas, realizar tests…

El procedimiento principal de la aplicación, incluye que el sistema,

una vez tenga una o varias imágenes, sea capaz de pasarlas al elemento extero

DLLs y que se transforme según los algoritmos que independientemente a BPACI

se hayan desarrollado, devolviendo de nuevo al sistema una o varias imágenes.



USUARIO

0.

BANCO DE PRUEBAS

PARA ALGORITMOS DE CRIPTOGRAFÍA

CON IMÁGENES

Entrada_nueva

Entrada_nombre_archivo

Imagen_guardada

Imagen guardada como imagen/texto

Imágenes criptar

Long clave

propiedades

Clave generada

Imagen BPACI

test

DLLS

imagenImágenes

a criptar

Img criptadas

Entrada_algoritmo

Nuevo algoritmo

Metodo, objeto

Color, coordenadas

Figura 5: Diagrama de contexto



5.1.2 DIAGRAMA DE PRIMER NIVEL

Explotando el nivel “0. BANCO DE PRUEBAS PARA ALGORITMOS

DE CRIPTOGRAFÍA CON IMÁGENES”, visto en el diagrama de contexto,

obtenemos una visión global de las funciones del sistema.

Se observa que la mayoría de los procesos requieren tener al menos

una imagen en pantalla. Las imágenes se abren desde el proceso “1.Archivo” y

van añadiéndose al almacén “IMÁGENES ABIERTAS” que nos permitirá

trabajar con aquella que se seleccione en cualquier instante de la ejecución. Una

vez se tenga una imagen abierta, se podrá aplicarse sobre ella cualquiera de los

procesos indicados, sin ningún orden predeterminado establecido.

Sin embargo, también existen procesos que no se aplican sobre

imágenes y por tanto, podrán ejecutarse sin antes tener que abrir una imagen. Es

el caso de generar claves, en el cual con introducir la longitud de clave deseada,

será suficiente para su generación.



1. Archivo

2. Edición

8. Tests

4. Criptografía

3. Ver

7. Ventana

5. Colores

6. Utilidades

IMÁGENES

ABIERTAS

Entrada_nueva Entrada_nombre_archivo

Img guardada como imagen/texto

Imagen guardada

Long clave

Propiedades

imagenImagen copiada

Imagen editada

imagen

Imágenes criptar Img

criptadas Img a criptar

Img criptadas

imagen

Vistas imagen

imagen

Txt_imagen

Txt_modificado

Img_modificada

Clave_generada9. Mostrar usuario

Img_ordenadas

imagentest

Imagen BPACI

Nombre_archivo, imagenimagen

Ventana nueva

imagen

Entrada_algoritmo

Nuevo algoritmo

Metodo, objetoCoordenadas x,y

Color

Coordenadas x,y

Figura 6: Diagrama de Flujo Nivel 1



5.1.3 DIAGRAMA MENÚ ARCHIVO

Los procesos 1.3, 1.4 y 1.5 estarán disponibles una vez hay en pantalla

una imagen abierta.

Los procesos “1.3 Guardar” y “1.4 Guardar como…” permiten

almacenar la imagen seleccionada con el mismo o distinto nombre que el original

y en la ubicación que elija el usuario.

El proceso “1.5 Propiedades” mostrará alguna de las propiedades de la

imagen seleccionada previamente como: ancho de la foto, alto, ubicación, hora,…



1.1 Nuevo

1.5 Propiedades1.4 Guardar

como..1.3 Guardar

1.2 Abrir

IMÁGENES

ABIERTAS

Entrada nueva

Ventana nueva

Imagen, nombre_archivo

Propiedades imagen

Entrada nombre_archivo

imagen

imagen

Imagen, nombre_a

rchivo

Imagen guardada

Imagen guardada

como imagen

Imagen guardada

como texto

Figura 7: Diagrama de Flujo Archivo



5.1.3.1 DIAGRAMA ABRIR

El sistema es capaz de abrir una imagen que previamente ha sido

guardad con cualquier formato de imagen (jpg, bmp, tiff,..).

Pero también será posible abrir una imagen que ha sido guardada como

texto. El sistema leerá este archivo de texto, y tras eliminar la cabecilla donde se

detallan propiedades de la imagen, transformará el texto en una imagen, la cual se

mostrará por pantalla.



1.2.1 Determinar extension

Entrada nombre_archivo

1.2.2 Abrir imagen

1.2.2 Leer texto

Archivo_texto

Archivo_imagen

1.2.3 Eliminar cabecilla

1.2.4 Transformar a bytes

1.2.5 Transformar bytes a imagen

Texto archivo

Texto sin cabecilla

Texto_en_bytes

imagen

imagen

imagen

Figura 8: Diagrama de Flujo de Datos de Archivo->Abrir



5.1.3.2 DIAGRAMA GUARDAR COMO..

Se detalla el proceso inverso al mencionado en el último DFD. Si antes

se explicaba como abrir una imagen a partir de una archivo de texto, ahora se

pretende guardar una imagen abierta en un archivo de texto. Para ello la imagen

será leida por el sistema y se guardará cada uno de los pixeles de la imagen con su

valor correspondiente en un archivo de texto.



1.4.6 Guardar imagen como

texto

1.4.5 Transformar a texto

1.4.3 Calcular datos cabecilla

1.4.4 Transformar imagen en array

de bytes

1.4.2 Guardar imagen como

imagen

1.4.1 Calcular direccion, formato

Direcc_imagen, formato Direcc_texto,

imagen

Direcc_texto, imagen

Imagen en

bytes

cabecilla

Texto_imagen

Imagen guardada como texto

Imagen guardada

como imagen

imagen

Figura 9: Diagrama de Flujo de Datos de Archivo->Guardar como..



5.1.4. DIAGRAMA MENU EDICION

Posibilidad de cortar y copiar cualquiera de las imágenes abiertas en

BPACI. También existe la posibilidad de pegar imágenes que previamente hayan

sido colocadas en el portapapeles.

Con los procesos “2.4 Voltear horizontalmente”, “2.5 Girar 180º” y

“2.6 Voltear verticalmente” se consigue que la imagen seleccionada entre las

imágenes abiertas realice uno de estos cambios y se muestre en pantalla el

resultado.



2.1 Cortar

2.5 Girar 180º

2.4 Voltear Horizontal_

mente

2.6 Voltear Verticalmente

2.3 Pegar

2.2 Copiar

IMÁGENES

ABIERTAS

Imagen copiada

Imagen a pegar

Imagen cortada

PORTAPAPELES

Imagen cortada

Imagen copiada

Imagen a pegar

Imagen Imagen

Imagen

Img volteada

horizontal_mente

Img volteada

verticalmen_te

Imggirada

Figura 10: Diagrama de Flujo de Datos de Edición



5.1.4 DIAGRAMA MENÚ VER

Con los dos primeros procesos “3.1 Barra de estado” y “3.2 Barra de

herramientas” podemos cambiar la vista del usuario, quitando o añadiendo tales

barras de la interfaz, e indicando estos hechos con un tic a la izquierda de los

submenús.

El resto de procesos nos permiten ver la imagen a tamaño completo, es

decir, ver toda la imagen en la pantalla en el ordenado o a tamaño real. También

podremos ver la imagen procesada que será aplicándole filtros de colores y

aparece también el proceso “3.6 Zoom”, la posibilidad de acercar o alejar la

imagen seleccionada en pantalla.

El almacén “Imágenes abiertas” pertenece a un nivel superior pero

aparece aquí indicado, para aclaración del lector.



3.3 Procesar

3.2 Imagen real

3.4 Zoom

3.1 Imagen completa

IMÁGENES

ABIERTAS

Imagen completa

Imagen real

Imagenprocesada

Imagen con

zoom

imagen

imagen

imagenimagen

Figura 11: Diagrama de Flujo de Datos de Ver



5.1.5 DIAGRAMA MENÚ CRIPTOGRAFÍA

El proceso “4.1 Añadir algoritmo” nos permitirá añadir una DLL que

no se haya cargado al inicio del programa. El usuario indicará la DLL a añadir y

ésta se añadirá en la dirección indicada en el archivo .xml para las DLLs.

En el proceso “4.2 Selección algoritmo”, se selección la DLL con la

que se quiere trabajar, se le pasará la imagen abierta u otras imágenes que no lo

estén, y éstas serán tratadas según el algoritmo de criptografía que se haya

seleccionado. Tras esta transformación, la imagen o imágenes resultantes se

mostrarán por pantalla al usuario.



4.1 Añadir Algoritmo

4.2 Aplicar algoritmo

Nuevo algoritmo

IMÁGENES

ABIERTAS

Img criptadas

Imágenes a criptar

Img criptadas

Entrada_algoritmo

imagen

Imágenes criptar

imagen

Metodo, objeto

Figura 12: Diagrama de Flujo de datos de Menú Criptografía



5.1.6.1 DIAGRAMA APLICAR ALGORITMO

Lo primero necesario para poder acceder a una DLL independiente de

BPACI, es crear el assembly que se hará a partir de la dirección completa donde

se encuentra la DLL que queremos ejecutar. Una vez creado el assembly,

buscaremos los métodos de las clases que buscamos, y una vez detectado el

método, le pasaremos al terminador externo DLLs el objeto donde se debe

invocar, el método que se quiere invocar y la imagen o las imágenes que proceda

en cada caso. Con estos datos, se accederá a la DLL especificada, se tratará la

imagen o imágenes con el algoritmo codificado en su interior y se devolverán una

o varias imágenes, según el caso. Las imágenes devueltas, pasarán pro el proceso

“4.2.7 Mostrar Img criptadas”, que transformará las imágenes devueltas para

mostrarlas en pantalla.



4.2.1 Calcular direcc DLL

imagen

4.2.2 Crear assembly

Direcc_DLL

4.2.6 Actuar con DLL tipo

N a N

4.2.5 Actuar con DLL tipo

1 a N

4.2.3 Recuperar

objetos devueltos

assembly

4.2.4 actuar con DLL tipo

1 a 1

imagen

Metodo, objeto

Imágenes criptar

Metodo, objeto,imagen

Metodo, objeto

Metodo, objeto,imagen

Metodo, objeto,imágenes

a criptar

4.2.7 Mostrar Img criptadas

Img criptadas

Img criptadas

Metodo, objeto

Figura 13: Diagrama de Flujo de Datos Criptografia-> Algoritmo



5.1.7 DIAGRAMA MENÚ COLORES

Partiendo de una imagen seleccionada de las que están abiertas en el

programa, podremos cambiar el color de uno de sus píxeles de dos maneras: una

de ellas introduciendo las coordinas del píxel a mano y eligiendo el color en una

paleta de colores; la otra forma, pasar antes por el proceso “4.2 Datos píxel” que

modifica el texto de la imagen, añadiendo las coordenadas y los colores RGB de

cada píxel por los que pasa el ratón al moverse. Si partimos de este punto, no hará

falta introducir las coordenadas, ya que el propio sistema será capaz de

reconocerlas, y solo habrá que seleccionar el color de la paleta de colores.



5.1 Modificar color pixel

5.2 Datos de cada pixel

IMÁGENES ABIERTAS

imagen

Imagen modificada

Texto imagen

Texto modificado

Coordena_da X Coordena_

da YColor

Coordenadas X, Y

5.3 Rellenar coordenadas

Figura 14: Diagrama de Flujo de Datos de Menú Colores



5.1.8 DIAGRAMA MENÚ UTILIDADES

Es una de las pocas funcionalidades de BPACI que no requieren tener

alguna imagen abierta.

Al hacer clic en Generar clave aparecerá una ventana donde el usuario

tendrá que introducir la longitud de clave que desea obtener y el sistema generará

una clave hexadecimal de esa longitud. Sólo se podrá tener una de estas imágenes

abiertas, pero se tiene la posibilidad de calcular varias claves, gracias al botón

RESET que aparecerá en pantalla.



5.1 Generar clave

Entrada longitud

claveClave

generada

Figura 15: Diagrama de Flujo de Datos de Menú Utilidades



5.1.9 DIAGRAMA MENÚ VENTANA

Todas las ventanas de imágenes abiertas en un instante de la ejecución

pueden ser ordenadas en forma de cascada, horizontal o verticalmente según las

exigencias del usuario.



7.1 Cascada

7.3 Ordenar verticalmente

7.2 Ordenar horizontalmen

te

IMÁGENES ABIERTAS

Img en cascasa

Img en horizontal

Img en vertical

Figura 16: Diagrama de Flujo de Datos de Menú Ventana



5.1.10 DIAGRAMA MENÚ TESTS

A partir de una imagen seleccionada, existe la posibilidad de realizar

diversos tests que nos permitirán evaluar la calidad de criptografía de una imagen.

Podremos realizar un test de histograma, de correlación vertical, de correlación

horizontal o de correlación diagonal. El proceso 8.5 calcula los cuatro tests al

mismo tiempo y los mostrará los cuatro en una única ventana al usuario.



8.1 Histograma

8.3 Correlación horizontal

8.4 Correlación

diagonal

8.2 Correlación

vertical

IMÁGENES

ABIERTAS

8.5 Todos los tests

8.6 Mostrar test

test

histograma

Correlación vertical Correlación

horizontal

Correlación diagonal

Todos los tests

imagen

imagen

imagen

imagenimagen

Figura 17: Diagrama de Flujo de Datos de Menú Tests



6. PROGRAMACIÓN

El objetivo de esta etapa es alcanzar la transformación del sistema en

un conjunto de programas que puedan ser ejecutados correctamente, bajo criterios

de calidad. La dificultad estriba en cómo realizar esta transformación de la mejor

manera posible, ya que va a depender de factores como el lenguaje de

programación a utilizar, herramientas y utilidades de software disponible, y

equipo de programación.

El lenguaje utilizado para este proyecto ha sido C# bajo la

plataforma.NET.

La elección de este lenguaje se debe a que es un lenguaje sencillo y

moderno orientado a objetos y con seguridad de tipos.

Visual C#.NET es la herramienta de desarrollo de C# de Microsoft que

incluye un entorno de desarrollo interactivo , diseñadores visuales para generar

aplicaciones para Windows y Web, un compilador y un depurador. Visual

C#.NET forma parte de un conjunto de productos denominado Visual

Studio.NET.



7. PRUEBAS DEL SISTEMA

Cada vez que se va implementando algo, lo ideal es hacer la prueba

unitaria, para comprobar que todo funciona correctamente. Si no fuese así, se debe

corregir en el instante y no dejar que el error se propague, lo cual puede llevar a

consecuencias muy negativas.

Estas pruebas deben hacerse a lo largo de todo el proyecto.

7.1 TIPOS DE PRUEBAS

Algunas de las pruebas que se han llevado a cabo en este prioyecto se

mencionan a continuación.

7.1.1 Pruebas unitarias

Se realizan pruebas de cada funcionalidad, para comprobara su

validez. Se realizan durante la fase de programación y las realiza el programador

que está a cargo de tales funcionalidades.



7.1.2 Pruebas del sistema

Van dirigidas al estudio de rendimientos, volúmenes y

viabilidad del sistema en producción. Se realizan en un entorno de pruebas y

constan de una serie de pruebas.

7.1.3 Pruebas de usabilidad del sistema

Determinan el manejo de la aplicación. Se realizan desde el

punto de vista técnico: normas y estándares.

7.1.4 Pruebas de aceptación del usuario

Las realiza el usuario para validar su aplicación, desde el punto

de vista funcional y operativo. Se realizan en entorno similar a producción.

7.1.5 Pruebas de implantación

Las realiza el personal encargado de la implantación y

garantizan la correcta generación del software, su distribución y explotación.



8. ACCESO A LOS ALGORITMOS DE

CRIPTOGRAFÍA CON IMÁGENES

Como se ha visto en la arquitectura, estos algoritmos se encuentran

compilados en DLLs ubicadas en una dirección especificada en el archivo

config.xml.

En este apartado explicaremos que mecanismos se han utilizado para

poder acceder a tales algoritmos.

El espacio de nombres imprescindible para el acceso es Reflection, que

nos permitirá recuperar información de los metadatos de los ensamblados

cargados. En este proyecto se ha utilizado este mecanismo para recuperar

información acerca de los métodos de las clases implementados en las DLLs.

Para acceder a los metadatos de cualquier ensamblado se utilizan las

clases del espacio de nombres System.Reflection.

Una vez obtenido el objeto que representa a un ensamblado (1) pueden

obtenerse los objetos Type que representan a sus tipos a través de su método

Type[] GetTypes[] (2).



A partir del objeto Type que representa un tipo puede obtenerse los

objetos MemberInfo[] que representan a sus miembros a través de su método

MemberInfo[] GetMembers[] (3).

Una vez obtenido un objeto MemberInfo, a través de sus métodos

GetMethods[], GetEvents[], GetProperties(), … podemos obtener la información

que deseemos. En nuestro caso, el método utilizado aquí ha sido GetMethods[]

(4), ya que los diferente tipos de DLLs se van a diferenciar por los argumentos

que se pasan y se devuelven a los métodos.

Estas relaciones vienen explicadas en la Figura 4. Los números indican

el orden de ejecución.



Figura 18: Arquitectura detallada

Tras haber seleccionado la DLL con la que se quiere trabajar, estos son

los pasos que se realizan en la lógica de negocio para acceder a la DLL y pasarle

los argumentos que requiere.

1. Con la dirección de la DLL, se crea un objeto ensamblado. Assembly sysAssem;

sysAssem = Assembly.LoadFrom(sDireccAlgoritmo);

REFLECTION

ENSAMBLADO

1..*

1..* 1..*

1..*

MÉTODOS

BPACI TIPOS

MIEMBROS

PROPIEDAD

1

2

3

……

4



2. Se obtienen los tipos definidos en este ensamblado. Type[] sysTypes; sysTypes = sysAssem.GetTypes();

3. Devuelve todos los miembros públicos del objeto Type actual

como MemberInfo.

4. Obtiene todos los metodos del objeto de la clase utilizado para

obtener esta instancia de MemberInfo.

Para cada método, se busca si devuelve uno de los siguientes tipos:

a) System.Drawing.Bitmap

b) System.Object

c) System.Object[]

Si se da el caso a), la DLL requiere que se le pase una imagen, que

será aquella que está abierta, y devolverá también una imagen.

El caso b) obligará a pasar varias imágenes, y devolverá una sola

imagen.



Por último el caso c), necesitará que se le pasen varias imágenes, y

también se devolverán varias imágenes.

Una vez, detectado el tipo devuelto, el procedimiento desarrollado para

cada caso es similar.

Llegados a este punto, tenemos identificados ya los siguientes datos: el

ensamblado(sysAssem), el objeto Type (objType), el objeto

MemberInfo(objMemberInfo) y el metodo.

Ya podemos interactuar con el algoritmo codificado en la DLL.

5. Creamos una instancia del ensamblado. object oMyObject;

oMyObject =

sysAssem.CreateInstance(objType.ReflectedType.ToString());

6. Convertimos la imagen o imágens a object[]. (object[] img)

7. Se invoca al miembro especificado, que nos devolverá la

imagen o imágenes una vez tratadas con el algoritmo específico de la DLL. object oReturn; // para los casos a) y b)

object[] oReturn; // para el caso c)

oReturn= oMyObject.GetType().InvokeMember(objMemberInfo,



BindingFlags.InvokeMethod, null ,oMyObject,img);

8. Las imágenes son recibidas como objetos, por tanto, habrá que

convertirlas a bitmap para poder mostrarlas por pantalla.



9. LIBRERÍAS DE ENLACE DINÁMICO

En este proyecto, como ya se ha comentado en repetidas ocasiones, los

algoritmos de criptografía gráfica se añaden en forma de DLLs.

En este apartado se pretende explicar el por qué de la elección de la

vinculación dinámica.

Algunas de las ventajas de los archivos DLL:

1.- Ahorra espacio en disco. Varias aplicaciones pueden compartir una

única copia de un archivo DLL en disco.

2.- Ahorra memoria y reduce el intercambio de páginas. Muchos

procesos pueden utilizar simultáneamente un mismo archivo DLL, compartiendo

una sola copia del mismo en la memoria.

3. Es más fácil actualizar archivos DLL. Cuando cambien las

funciones de un archivo DLL, no será necesario volver a compilar y vincular las



aplicaciones que las utilizan si no cambian los argumentos de la función y los

valores devueltos.

El motivo de usar este tipo de archivos en el proyecto, es que se

pretende que personas ajenas a esta aplicación puedan utilizarla para fines de

criptografía gráfica, es decir, que la aplicación se adapte a las necesidades de cada

uno, sin necesidad de retocar el código propio de BPACI. Esto es posible ya que

al desarrollar una DLL se tratará como archivo independiente, pudiendo añadir o


compilar y ejecutar BPACI siempre que no cambien los argumentos de las

funciones y los valores devueltos.

Para ello conviene seguir los pasos de creación de una DLL para

BPACI indicados en el punto siguiente “10. Plantillas para las DLLs”.



10. PLANTILLAS PARA LAS DLLs

La novedad de esta aplicación es poder añadir al programa algoritmos

de criptografía en forma de DLLs, y que el sistema sea capaz de interactuar con

ellas.

Para esto, es necesario seguir estos pasos y utilizar las plantillas que se

detallan a continuación.

Los tres tipos de algoritmos de criptografía con imágenes que el

sistema reconoce son:

Plantilla 1: Recibe 1 imagen como argumento y devuelve una imagen

procesada

Plantilla 2: Recibe varias imágenes como argumento y devuelve una

sola imagen.

Plantilla 3: Recibe varias imágenes como argumento y devuelve

también varias imágenes.



Figura 19: Interacción BPACI con DLLs

Como se puede comprobar a continuación, las tres plantillas tienen

características comunes:

- Los nombres de los métodos y de los argumentos

pueden ser modificados, pero no puede serlo el tipo de valor devuelto,

ni el tipo de los argumentos.

- En las tres plantillas, es necesario incluir una interfaz

donde el usuario pueda introducir la clave con la que desea cifrar o

descifrar la imagen o imágenes. Esta ventana puede variar según el

gusto del usuario y las necesidades de cada algoritmo.

Plantilla 1

Plantilla 2

Plantilla 3

11

N1

NN

BPACI



En el anexo A, se muestra el código para una ventana común, que es la

que se ha llamado form1 en las plantillas. Este código debe ir incluido en:

En este anexo A se detalla también la programación de las tres

plantillas.

Figura 20: Posible interfaz de los algoritmos

Los ejemplos donde se usan estas plantillas, están reflejados en el

Anexo C-Manual de Usuario en las Figuras 52-59.



11. OTRAS PLANTILLAS

En este apartado se pretende optimizar el uso de lo que se ha

programado para la utilización de los algoritmos de criptografía.

El objetivo del código implementado en la aplicación era que BPACI

fuese capaz de reconocer las DLLs añadidas dinámicamente en el programa y que

pudiese interactuar con ellas, tal y como se detalla en el capítulo 10 de esta

memoria.

Otra utilidad derivada de esta interacción BPACI DLLs, es la

posibilidad de añadir funciones para procesar imágenes en forma de DLLs.

El ejemplo que se muestra en el anexo B consiste en aplicar un filtro

rojo a una imagen abierta en pantalla.

El procedimiento para añadir esta DLL dinámicamente será el mismo

que el utilizado para los algoritmos.

Ver Anexo B.



12. COMPILAR LAS DLLs

Una vez creado y guardado el algoritmo de criptografía tendremos un

archivo .cs. Este archivo hay que convertirlo a DLL para que BPACI lo reconozca

como tal, y pueda trabajar con él.

El modo de conseguir el archivo DLL se explica a continuación.

1.- Se necesitará abrir el símbolo del sistema de Visual Studio.NET

2003. Lo encontraremos siguiendo estos pasos:



Figura 21: Abrir ventana para compilar DLL



Pulsando sobre “Símbolo del sistema de Visual Studio.NET 2003”,

nos aparecerá una ventana como la de la Figura 21.

Figura 22: Pantalla para compilar DLL

2.- Una vez en esta pantalla, mediante los comandos necesarios,

debemos indicar la dirección donde se encuentra almacenado nuestro algoritmo.

En este ejemplo, le hemos llamado “MiCifrado.cs”, y se encuentra en

“C:\Documents and Settings\BPACI”.



Figura 23: comandos ventana



3.- La línea de comando para compilar el archivo “MiCifrado.cs” y

obtener la DLL “MiCifrado.DLL”.

csc /target:library /out:MiCifrado.DLL MiCifrado.cs

Figura 24: línea de comando para compilar una DLL



4.- En la dirección donde antes teníamos “MiCifrado.cs”, ahora

aparecerá también el archivo “MiCifrado.DLL”

Figura 25: DLL compilada

5.- El último paso necesario para que el programe cargue

“MiCifrado.DLL” al inicio de la ejecución, es colocar el archivo en la dirección

que se indica en el archivo config.xml.



Otra solución, puede ser ejecutar el programa, y en el menú

Criptografia, pulsar “Añadir Algoritmo” o la tecla F5. Se buscará el archivo y se

hará una copia en la dirección config.xml. La próxima vez que se ejecute el

programa, “MiCifrado.DLL” se cargará automáticamente.

Figura 26: Añadir la DLL a BPACI



13. REQUISITOS HARDWARE

La herramienta utilizada para el desarrollo de este proyecto ha sido

Visual Studio.NET 2003 y la edición empleada la Professional.

Los requisitos mínimos del sistema para ejecutar esta herramienta vienen

determinados en la tabla siguiente.

Visual Studio.NET 2003 (todas las ediciones)

Procesador

Procesador Pentium II a 450 MHz

Se recomienda Pentium III a 600 MHZ

Sistema

operativo

Visual Studio.NET 2003 se pueden instalar en cualquiera de los

siguientes sistemas:

Microsoft Windows® Server 2003

Windows XP Professional

Windows XP Home Edition1

Windows 2000 Professional

Windows 2000 Server



Las aplicaciones se pueden implementar en los siguientes

sistemas2

Windows Server 2003

Windows XP Professional

Windows XP Home Edition

Windows 2000 (se recomienda Service Pack)

Windows Millenium Edition (Windows Me)

Windows 98

Microsoft Windows NT® 4.0 (se precisa Service Pack 6a)

Windows 95 (utilizando Microsoft Visual C++®.NET)

Memoria

Windows Server 2003: 160 MB de memoria RAM

Windows XP Professional: 160 MB de memoria RAM

Windows XP Home Edition: 96 MB de memoria RAM

Windows 2000 Professional: 96 MB de memoria RAM

Windows 2000 Server: 192 MB de memoria RAM

Disco duro

900 MB de espacio disponible en la unidad del sistema; 3,3 GB de

espacio disponible en la unidad de instalación

1,9 GB de espacio adicional disponible para la documentación de

MSDN Librería opcional

Unidad de

disco

Unidad de CD-ROM o DVD-ROM



Monitor

Resolución Super VGA (1024 x 768) o superior con 256 colores

Mouse

Microsoft Mouse o compatible

1 Funcionalidad limitada. Visual Studio .NET 2003 no admite la creación de aplicaciones

Web ASP.NET ni servicios Web, XML ASP.NET cuando se utiliza XP Home Edition.

2 Sólo se pueden alojar aplicaciones Web y servicios Web XML ASP.NET en Windows

XP Professional, Windows 2000 y Windows Server 2003.



14. INSTALACIÓN

Se pretende que esta aplicación pueda ejecutarse desde cualquier

ordenador. Para ello se ha creado una instalacion, con el nombre de

SetupBPACI que contiene lo siguiente.

Figura 27: Archivos del instalable



En la carpeta Debug encontraremos el Setup .exe para instalar BPACI.

Figura 28: Setup.exe de BPACI

Pulsando este elemento se ejecutará el programa de instalación donde

tendremos que indicar la dirección donde queremos que se instale.

Una vez terminada la instalación, los elementos que aparecerán en

nuestro ordenador serán los siguientes:



Figura 29: Los archivos instalados en el usuario

MyLibrary: Se encuentran las DLLs necesarias para la ejecuín de

BPACI

Plantillas: Aquí se encuentran las plantillas que podremos utilizar

para la creación de nuevos algoritmos de criptografía gráfica.

Estas plantillas están en formato .cs y explicadas en este

documento en el apartado 9.



GestionErrores: Contiene un archivo GestionErrores.log donde se

guardará información de la ejecución actual como la hora de comienzo, las DLLs

que se cargan, asi como algunos errores importantes.

DLLs: En el momento de la instalación está vacía, pero para

comodidad del usuario se recomienda que se copien aquí las DLLs con las que se

quiere trabajar.

Config.xml: Este archivo es el que contiene las direcciones del

archivo de gestion de errores y de la carpeta de las DLLs que queremos que se

ejecuten nada má iniciar la aplicación.

Lo primero que se debe hacer es abrir este archivo

Figura 30: Abrir config.xml



Al abrir el archivo tenemos

Figura 31: contenido del archivo .xml

Tenemos que escribir las direcciones que nos vayan bien como

usuario.

Así, la primera dirección nos indica la carpeta de las DLLs que se

cargarán al inicio, por tanto, debemos indicar las dirección de la carpeta.

En la segunda dirección, se indicará el archivo de Gestión de errores.

Si seguimos las instrucciones dadas hasta ahora, y dejamos el archivo

GestionErrores.log de la carpeta GestionErrores para este fin, la dirección a

escribir será:

@usuario\BPACI\GestionErrores\GestionErrores.log

BPACI.exe: una vez realizados los cambios en config,xml, ya

podemos ejecutar la aplicación pulsando BPACI.exe

1

2



15. CONCLUSIONES

Como conclusión al proyecto realizado, me gustaría comentar en este

apartado, las aportaciones realizadas con este proyecto, las dificultades con las que me

he enfrentado y algunas sugerencias de trabajo futuro.

15.1 APORTACIONES

El objetivo de este proyecto era conseguir un entorno integrado de

manipulación de imágenes con la posibilidad de añadir algoritmos de criptografía

en forma de plug-ins.

El resultado de este proyecto es que utilizando las plantillas generadas

y detalladas en el anexo A, cualquier persona sin necesidad de tener grandes

conocimientos de informática (bastará con saber programar el algoritmo), podrá

procesar imágenes digitalmente con los algoritmos que él haya implementado.

Los algoritmos se añadirán al programa como archivos DLLs. El

motivo de usar este tipo de archivos en el proyecto, es que se pretende que

personas ajenas a esta aplicación puedan utilizarla para fines de criptografía

gráfica, es decir, que la aplicación se adapte a las necesidades de cada uno, sin

necesidad de retocar el código propio de BPACI. Esto es posible ya que al

desarrollar una DLL se tratará como archivo independiente, pudiendo añadir o




compilar y ejecutar BPACI siempre que se respeten las plantillas diseñadas.

Tal y como indica el nombre del proyecto “Banco de Pruebas Para

Algoritmos de Criptografía Gráfica” esta aplicación es un banco de pruebas donde

se podrán probar distintos algoritmos. Cada usuario puede usar y probar los suyos,

ya que la dirección desde donde se cargan los archivos DLL es variable, y cada

usuario podrá introducir la que en ese momento desee.

Esto permite ampliar el campo de trabajo sobre la criptografía de

imágenes y que mayor número de gente sea capaz de contribuir al estudio de la

seguridad.

Dificultades

Las dificultades mayores con las que nos hemos enfrentado en este

proyecto, ha sido el poder llamar dinámicamente archivos y el poder interactuar

con ellos. Para conseguir esto han sido imprescindibles los espacios de nombres

System.Reflection y System,InteropServices que nos han proporcionado los

métodos necesarios para obtener información sobre objetos en tiempo de

ejecución.

Otra de las complicaciones con las que hemos tenido que tratar, están

relacionadas con el trabajo con imágenes. Ya que es muy diferente a trabajar con

un archivo de texto. Tenemos que tener en cuenta, que una imagen es una matriz



bidimensional, con columnas y filas, con sus tamaños correspondientes. Un

pequeño descuido en uno de los elementos o tamaños de la matriz, ofrece

resultados incorrectos.

15.2 SUGERENCIAS DE TRABAJO FUTURO

Las futuras mejoras estarían más dedicadas al aspecto gráfico de la

aplicación, es decir, a la implementación de más funcionalidades para BPACI.

Actualmente lo que se ha conseguido es un entorno lo suficientemente integrado

para la manipulación de imágenes que nos permite realizar las funciones más

conocidas e indispensables para la ejecución de un programa de imágenes.



16. PLANIFICACIÓN DEL PROYECTO

En esta fase se pretende diferencias las subtareas ealizadas para llevar

a cabo el proyecto final. También planificar las dependencias entre estas tareas, y

los recursos necesarios para cada etapa. Finalmente aparecerá el grñafico de las

tareas distribuido en el tiempo.

16.1 DEFINICIÓN DE TAREAS

Subtarea 1 (S1)

Fase de diseño: definir los requisitos funcionales, no funcionales,

arquitectura del sistema

Subtarea 2 (S2)

Desarrollar el entorno integrado de manipulación de imágenes de

BPACI.

Subtarea 3 (S3)

Desarrollo de los interfaces con bibliotecas dinámicas de manera que

el entorno pueda cargar distintos algoritmos de criptografía gráfica.



Subtarea 4 (S4)

Adición de utilidades a BPACI.

Subtarea 5 (S5)

Programación de diversos tests estadísticos para evolución de la

seguridad.

Subtarea 6 (S6)

Pruebas de usuarios

Subtarea 7 (S7)

Pruebas del sistema

Subtarea 8 (S8)

Redacción del manual de usuarios

16.2 DEPENDENCIAS ENTRE TAREAS

Hasta que la primera subtarea no finalizó, no se pudó comenzar el resto, ya

que en esta etapa, se definía el alcance del proyecto, y se hacía un diseño de cómo

será la aplicación que se desarrollaría en las siguientes subtareas.

Las pruebas del sistema se han ido realizando a lo largo de todo el desarrollo

del proyecto para ir comprobando el comportamiento correcto de la aplicación.



16.3 RECURSOS

En la subtarea 1, el objetivo era hacerse una idea general del proyecto y de las

tareas que debían llevarse a cabo, cómo realizarlas y cuándo.

A partir de la subtarea 2 hasta el final de la subtarea 7, se comienza a

programar. El proyecto se ha desarrollado en C# en la plataforma .NET.

El software requerido ha sido Visual Studio.NET.

El hardware requerido un ordenador que pudiese soportar el software.

16.4 PLANIFICACIÓN

Figura 32: Planificación del proyecto



17. PRESUPUESTO DEL PROYECTO

En el presupuesto del proyecto se procede a realizar una valoración

económica de los costes tangibles asociados al desarrollo del proyecto.

Según lo visto en el apartado anterior, lo único necesario para

desarrollar esta aplicación, es comprar la licencia del Microsoft Visual Studio

.NET Professional y un ordenador donde se pueda ejecutar este programa.

El coste final del proyecto se valorará a partir del precio del software y

del coste hora de los programadores, en este caso, un único programador. No se

calculan costes de implantación, ya que la interfaz desarrollada es bastante

intuitiva y bastará con el manual de usuario que se encuentra en el Anexo C.

Las horas calculadas para la elaboración de este proyecto han sido 600

horas. Con un precio de 30€/h, el coste de desarrollo quedaría en 18000€.

El precio de Visual Studio.NET Professional puede variar alrededor de

un precio de 475€.

Coste total: 18000 + 475 = 18475€ / proyecto



18. BIBLIOGRAFÍA

[WRIG03] Wright, Charles, “Superutilidades para C# ”,

McGrawHill 2003

[BARR01] Barranco de Areba, Jesús, “ Metodología del

Análisis estructurado ”, Publicaciones de la

Universidad Pontificia Comillas, Madrid 2001

[BRAV99] Bravo Montero, Joaquin,

http://programacion.net/html/xml , “ Tutorial

de XML” en castellano 1999

[DEVE05] Developer Center Microsoft Visual C#

http://msdn.microsoft.com/vcsharp/



ANEXOS



ANEXO A

PLANTILLAS PARA LAS DLLs

La interfaz que se muestra en la fugura siguiente es la interfaz diseñada para

las plantillas. Se hara referencia a ella como form1.

Figura 33: Posible interfaz de los algoritmos

El código viene implementado a continuación



Código de la figura 19

#region Código generado por el Diseñador de Windows Forms

/// <summary> /// Método necesario para admitir el Diseñador. No se puede modificar

/// el contenido del método con el editor de código. /// </summary>

private void InitializeComponent() {

form1= new Form();

btCifrar = new System.Windows.Forms.Button(); btDescifrar = new System.Windows.Forms.Button();

textBoxClave = new System.Windows.Forms.TextBox(); labelClave = new System.Windows.Forms.Label();

form1.SuspendLayout(); //

// btCifrar //

btCifrar.Location = new System.Drawing.Point(128, 120);

btCifrar.Name = “btCifrar”; btCifrar.Size = new System.Drawing.Size(112, 32);

btCifrar.TabIndex = 0;

btCifrar.Text = “Cifrar”;

this.btCifrar.Click += new

System.EventHandler(this.btCifrar_Click);



//

// btDescifrar //

btDescifrar.Location = new System.Drawing.Point(336, 120);

btDescifrar.Name = “btDescifrar”;

btDescifrar.Size = new System.Drawing.Size(112, 32);

btDescifrar.TabIndex = 1;

btDescifrar.Text = “Descifrar”;

btDescifrar.Click += new System.EventHandler(btDescifrar_Click); //

// textBoxClave //

textBoxClave.Location = new System.Drawing.Point(152, 50);

textBoxClave.Name = “textBoxClave”;

textBoxClave.Size = new System.Drawing.Size(416, 20);

textBoxClave.TabIndex = 2;

textBoxClave.Text = “”; //

// labelClave //

labelClave.Location = new System.Drawing.Point(40, 48); labelClave.Name = “labelClave”;

labelClave.Size = new System.Drawing.Size(88, 24);

labelClave.TabIndex = 3;

labelClave.Text = “ Clave”;



//

// Clave

//

form1.AutoScaleBaseSize = new System.Drawing.Size(5, 13);

form1.ClientSize = new System.Drawing.Size(576, 182);

form1.Controls.Add(labelClave);

form1.Controls.Add(textBoxClave);

form1.Controls.Add(btDescifrar);

form1.Controls.Add(btCifrar);

form1.Name = “Clave”;

form1.Text = “Clave”;

form1.ResumeLayout(false);

}

#endregion



PLANTILLA 1: Recibe 1 imagen como argumento y devuelve una imagen procesada.

using System;

using System.Drawing;

using System.Windows.Forms;

namespace nombre_namespace

{

/// <summary>

/// Descripción breve de Cifrado.

/// </summary>

public class Plantilla1

{

// Formulario diseñado para introducir la clave

Form form1;

//imagen que se devolvera a BPACI

Bitmap bmpFin;

public Button btCifrar;

public Button btDescifrar;

public TextBox textBoxClave;

public Label labelClave;

string sClave="";



/// <summary>

/// Constructor

/// </summary>

public Plantilla1()

{

InitializeComponent();

}

// CÓDIGO FIGURA 19

private void btCifrar_Click(object sender, System.EventArgs e)

{

this.sClave= textBoxClave.Text;

if(this.sClave!= "")

{

form1.Dispose();

}

else

{

MessageBox.Show("ESCRIBA LA CLAVE PARA

CIFRAR");

}

}



public static Bitmap ImagenCifrado(Image imImagen)

{

Plantilla1 plantilla= new Plantilla1();

// Mostrar la ventana diseñada para introducir la clave

plantilla.form1.ShowDialog();

Bitmap bmpInicio= null;

// Almacenar la imagen recibida de BPACI en la variable

// imagen

try

{

bmpInicio = (Bitmap)imImagen;

}

catch(Exception)

{

throw;

}

// Las medidas de la imagen final, en este caso,

// son iguales que las medidas de la imagen inicial

plantilla.bmpFin= new Bitmap(bmpInicio.Width,

bmpInicio.Height);



// ALGORITMO DE CRIPTOGRAFÍA

// En este ejemplo se recorre cada uno de los píxeles de la

// imagen

// y los píxeles que tengan la coordenada j par y la g impar se

// colorean en negro, el resto en blanco.

// Se ha trabajado a partir de colores.

//

// Puede ser útil el trabajar a partir de números

// Sin modificar mucho este código bastará con utilizar

// el siguiente método

// Color c= Color.FromArgb(int valorRojo,int valorVerde,int

// valorAzul);

//

Color color;

byte rojo;

byte verde;

byte azul;

for(int g=0; g<bmpInicio.Height; g++)

{

for(int j=0; j<bmpInicio.Width; j++)

{

color= bmpInicio.GetPixel(j,g);



if(j%2==0 && g%2!=0)

{

rojo= Color.Black.R;

verde = Color.Black.G;

azul= Color.Black.B;

}

else

{

rojo= Color.White.R;

verde= Color.White.G;

azul= Color.White.B;

}

// color del pixel (j,g) en la imagen final

plantilla.bmpFin.SetPixel(j,g,

Color.FromArgb(rojo,verde,azul));

}

}

// Imagen que se mostrará por pantalla

return plantilla.bmpFin;

}

}

}



PLANTILLA 2 Recibe varias imagines com argumento y devulee una sola imagen.

using System;




{

/// <summary>

/// Descripción breve de RepartoImagenes.

/// </summary>


{

object y;

Form form1;





string sClave="";

Bitmap imagen;



public Plantilla2()

{


}



{



{

form1.Dispose();

}

else

{


CIFRAR");

}

}



public object ImagenCifrado(Image[] arrayImg)

{

// Se calcula el número de imágenes con las que hay que

// trabajar

int numImg= arrayImg.Length;

byte azul;

byte rojo;

byte verde;

// Transformar todas las imágenes en Bitmap

Bitmap[] bmArray = new Bitmap[numImg];

for (int i=0; i<numImg; i++)

{

bmArray[i] =(Bitmap)arrayImg[i];

}


// Mostrar la ventana donde introducir la clave


// Tomar una imagen como referencia

plantilla.imagen= bmArray[0];

Image imagen2= bmArray[0];

Image original= arrayImg[0];



// Ancho y alto de la imagen tomada como referencia

int Hmenor= bmArray[0].Height;

int Wmenor= bmArray[0].Width;

// Calcular las medidas de la imagen final

for(int j=1; j<numImg; j++)

{

if(Hmenor < bmArray[j].Height)

{

Hmenor= Hmenor;

}

else

{

Hmenor= bmArray[j].Height;

}

if(Wmenor < bmArray[j].Width)

{

Wmenor = Wmenor;

}

else

{

Wmenor= bmArray[j].Width;

}

}



// Ajustar todas las imágenes a las medidas de la imagen final

Bitmap[] bmArrayRedimensionado= new Bitmap[numImg];

for(int k=0; k<numImg; k++)

{

bmArrayRedimensionado[k]= new Bitmap(bmArray[k],

Wmenor, Hmenor);

}

plantilla.imagen=bmArrayRedimensionado[0];


// En este ejemplo se elige un pixel de cada imagen para

// ir rellenando la imagen final. El resultado es la

// superposición de todas las fotos.

int resto;

for(int g=0; g<Hmenor; g++)

{

for(int j=0; j<Wmenor; j++)

{

resto = j%numImg;

rojo=

bmArrayRedimensionado[resto].GetPixel(j,g).R;



verde=

bmArrayRedimensionado[resto].GetPixel(j,g).G;

azul=

bmArrayRedimensionado[resto].GetPixel(j,g).B;

// Pintar el pixel (j,g) como el pixel de la imagen

// elegida

plantilla.imagen.SetPixel(j,g,

Color.FromArgb(rojo,verde,azul));

}

}

y= (object)plantilla.imagen;

return y;

}

}

}



PLANTILLA 3

Recibe varias imagines como argumento y devuelve también varias

imágenes.

using System;



using System.Collections;

using System.ComponentModel;

using System.Drawing.Imaging;


{

/// <summary>

/// Descripción breve de RepartoImagenes.

/// </summary>


{

// array que se devolverá a BPACI

object[] objFin;

Form form1;







string sClave="";

public Plantilla3()

{


}



{



{

form1.Dispose();

}

else

{


CIFRAR");



}

}

public object[] ImagenCifrado(Image[] arrayImg)

{

// array de imágenes

Image[] im;

// Numero de imagenes que llegan

int numImg;


// Mostrar la ventana para introducir la clave


numImg= arrayImg.Length;

im= new Image[numImg];

for(int j=0; j<numImg; j++)

{

im[j] = arrayImg[j];

}




// Aquí simplemente se devuelven las imágenes

// tal y como entraron, pero por supuesto, se pueden modificar

// las imágenes ahora almacenadas en el array im

// como se ha explicado en las dos plantillas anteriores

// Transformar las imagenes a bitmap

plantilla.objFin= new object[numImg];

for(int i=0; i<numImg; i++)

{

plantilla.objFin[i]= (object)(im[i]);

}

return plantilla.objFin;

}

}

}



ANEXO B

OTRAS PLANTILLAS

Puede ser interesante también la opción de añadir funciones en

archivos DLL para procesar imágenes. Esto nos permitiría repartir el peso de la

apliación. El código para esta implementación es más sencillo que el empleado

para las plantillas de algoritmos de criptografía.

En este código, lo que se hace es aplicar a la imagen un filtro rojo.

using System;


namespace Algoritmos

{

/// <summary>

/// Descripción breve de Class1.

/// </summary>



public class FiltroRojo

{

/// <summary>

/// Punto de entrada principal de la aplicación.

/// </summary>

public static Bitmap Alg1(Image abImagen)

{

// Imagen que se recibe como argumento

Bitmap imagen = (Bitmap)abImagen;

// Medidas de la imagen

int ancho, alto;

// Color del pixel

Color c;

ancho= imagen.Width;

alto= imagen.Height;

Bitmap bmp= new Bitmap(ancho, alto);

for(int y=0; y<imagen.Height; y++)

{

for(int x=0; x<imagen.Width; x++)

{

c= imagen.GetPixel(x,y);

bmp.SetPixel(x,y,Color.FromArgb(c.R,0,0));



}

}

return bmp;

}

}

}



ANEXO C

MANUAL DE USUARIO

En este manual se explicarán cada unas de las funciones del Banco de

Pruebas para Algoritmos de Criptografía con Imágenes.

Cuando se ejecuta la aplicación, antes de que aparezca la ventana

principal, el sistema lanza una serie de mensaje como el siguiente, indicando las

DLLs que se están añadiendo automáticamente a nuestra aplicación.

Figura 34: Información de los algoritmos añadidos inicialmente



Una vez aceptadas todas las DLLs, se abre la ventana principal, con la

siguiente apariencia.

Figura 35: Ventana principal

Observamos que consta de un menú con las opciones de Archivo,

Edición, Ver, Criptografía, Colores, Utilidades, Ventana, Tests y Ayuda

Cada uno de estos menús, tiene a su vez submenús que se irán

explicando a lo largo de este manual.



La aplicación también contiene una barra de herramientas, que nos

permitirán acceder más rápidamente a las acciones de Nuevo, Abrir, Guardar,

Acerca de.., Propiedades, Ampliar Zoom, Disminuir zoom, Actualizar, y también

elegir el nivel de zoom que deseemos.

Empezaremos a explicar cada una de las funcionalidades, siguiendo el

orden del menú.



MENÚ ARCHIVO

Figura 36: Menú Archivo

Nuevo: Aparecerá una nueva ventana sin ninguna imagen.



Figura 37: Ventana nueva

Abrir: Seleccionaremos la imagen que queremos que aparezca, y se

mostrará en una nueva ventana.

Las imágenes pueden estar en cualquiera de los formatos, .jpg, .jpeg,

.gif, .tiff, .bmp, .txte

Al abrir un archivo .txt, este si corresponde a una imagen que se ha

guardado como texto, se mostrará en pantalla en forma de imagen, y no

como texto.



Figura 38: Abrir ventana

En caso de abrir un archivo texto, que no corresponda a una imagen o

un archivo que haya sufrido modificaciones y ya no permita transformarse

en imagen, se mostrará alguno de los avisos mostrados en la Figura 30.



Figura 39: Error al guardar imagen

Guardar: Guardar la imagen en el mismo sitio donde se abrió.

Guardar como: Guardar la imagen abierta en cualquier otro lugar, o en un

formato distinto al que se abrió.

Se podrá guardar la imagen abierta en tipo texto, guardando en este

caso el valor numérico de cada píxel.

Propiedades: Se muestran en una nueva ventana modal que aprecerá en

pantalla las propiedades de la imagen seleccionada en ese instante.



Figura 40: Propiedades

Salir: Para abandonar la aplicación.



MENU EDICION

Figura 41: Menú Edición

Cortar: Cortará la imagen que está en pantalla.

Copiar: Hará una copia de la imagen seleccionada en pantalla.

Pegar: Pegará la imagen que se encuentre en el portapapeles en la ventana

seleccionada de nuestra aplicación.

Voltear Horizontalmente: Volteará la imagen seleccionada en la aplicación

horizontalmente.



Girar 180º: Girará la imagen seleccionad en la aplicación 180ª.

Voltear Verticalmente: Volteará la imagen seleccionada en la aplicación

horizontalmente.

Figura 42: Imagen abierta sin cambios



Figura 43: Figura 33 volteada horizontalmente

Figura 44: Figura 33 volteada verticalmente



MENÚ VER

Figura 45: Menú Ver

Barra de estado: Mostrar o no la barra de estado en la ventana principal.

Cuando ésta aparezca en pantalla, se marcará como se muestra en la imagen.

Barra de herramientas: Mostrar o no la barra de herramientas. Cuando ésta

aparezca en pantalla, se marcará como se muestra en la imagen.

Imagen completa: Nos permitirá ver la imagen ajustada al tamaño de la

pantalla.



Imagen real: Se mostrará con sus dimensiones reales, ajustando en cada

caso los scrollbars que nos permitirán desplazarnos por toda la imagen

Procesar: Tendremos la opción de aplicar a la imagen seleccionada en

pantalla un filtro de color azul, rojo y/o verde.

Zoom: Alejar o acercar la imagen indicando el nivel que queramos.

Utilizando el submenú Zoom podremos hacer un zoom máximo de 11.

Figura 46: Menú Ver->Zoom



Tenemos para hacer zoom, otras opciones que aparecen directamente

en la barra de herramientas.

Figura 47: Ampliar y Disminuir zoom en barra de herramientas

Ampliar zoom: Pulsando este botón la imagen se irá acercando poco a poco.

Disminuir zoom: Pulsando este botón la imagen se irá alejando poco a poco.

Cuando la imagen no pueda ampliarse más, se mostrará un mensaje

como este en pantalla.

Figura 48: Límite del zoom



Otra opción para aplicar el zoom a la imagen seleccionada en pantalla,

es escribir el nivel de zoom que se quiera aplicar directamente en la caja de

texto y pulsar el botón “Nivel Zoom”.

Figura 49: Nivel zoom en la barra de herramientas

Si este nivel no puede aplicarse directamente por conseguir imágenes

demasiado grandes, entonces se mostrará el siguiente mensaje por pantalla

que nos informará de tal situación.

Figura 50: Error de límite en el nivel de zoom



MENÚ CRIPTOGRAFÍA

Figura 51: Menú Criptografía

Los submenús que se cargan en el menú Criptografía, se cargan

automáticamente al iniciar el programa. Las DLLs que se añaden son

únicamente aquellas que se encuentran en la dirección especificada en el

archivo config.xml.

Algoritmo nuevo: Si queremos añadir un algoritmo nuevo, damos a

“Algoritmo nuevo” y buscamos la DLL que queremos añadir. La DLL se

carga directamente en el programa y se hace una copia en la misma



dirección desde donde se han cargado el resto. Así, no será necesario

reiniciar el programa cuando se quiera añadir un algoritmo nuevo, y además

la próxima vez que se cargue, esta última DLL, si no se ha eliminado, se

cargará al principio de la ejecución.

Para trabajar con cualquiera de los algoritmos añadidos, basta con

seleccionarlo. A partir de ahora se realizarán las operaciones implementadas

en el algoritmo.

En los siguientes ejemplos, vamos a distinguir los tres casos para los

cuales se han diseñado las plantillas.



CASO 1: Se pasa una imagen y se recibe esa imagen procesada.

Figura 52: Imagen que se va a procesar

Seleccionamos el algoritmo que queremos utilizar

Figura 53: Selección del algoritmo



Inmediatamente después, nos aparecerá la interfaz diseñada para la

DLL seleccionada. En este ejemplo, es una ventana sencilla donde se debe

introducir la clave de cifrado que se desee.

Figura 54: Clave para el algoritmo

El resultado de la imagen abierta antes cifrada con la clave indicada, es

el siguiente. El texto que aparece en la imagen procesada es el nombre de la

DLL que se ha utilizado, en este caso “cifrado con BYN.DLL##Zoom1” y el

nivel de zoom.



La comparación de la imagen antes y después del cifrado

Figura 55: Imagen procesada



CASO 2: Se pasan varias imágenes y se recibe una sola imagen procesada.

El procedimiento comienza igual que en el caso 1.

Pero al seleccionar el algoritmo, el sistema nos informa que tenemos

que seleccionar las imágenes que deseamos procesar. Cada vez que escojamos

una, el sistema nos pregunta si queremos incluir algunas más. Cuando el

usuario responde No, el sistema devuelve entonces la imagen resultante que se

ha procesado a partir de las anteriores.



Figura 56: Pasar varias imágenes a procesar

En este ejemplo, las imágenes que se han pasado han sido 3, que se

muestran en la Figura 57:

Figura 57: Imágenes a procesar



El resultado es:

Figura 58: Imagen procesada en el caso 2



CASO 3: Se pasan varias imágenes y se reciben varias imágenes procesadas.

El procedimiento y las ventanas que aparecen al usuario son las

mismas que en el caso 2. La diferencia está en que ahora se reciben varias

imágenes procesadas y no sólo una como en el caso anterior

EL resultado debe ser algo similar a lo mostrado en la Figura 59.

Figura 59: Imágenes procesadas en el caso 3



En cada texto de la imagen, aparece el nombre del cifrado con que se han

procesado las imágenes y además se indica el número de copia.

En el ejemplo anterior, se han devuelto tres imágenes, y por tanto, los títulos

serán:

- cifrado con de NaN.DLL_Copia1##Zoom:1





MENÚ COLORES

Figura 60: Menú Colores

Modificar color píxel: Para cambiar el color de un píxel. Aparecerá una

ventana como la siguiente.



Figura 61: Cambiar color píxel

Habrá que rellenar las coordenadas del píxel que se quiere cambiar,

línea y columna. Dando al botón Calcular, se rellenará el texto anterior con

el color actual de ese píxel. Y con el botón Color, aparecerá una paleta de

colores, donde podremos elegir el color al que deseamos cambiar.



Figura 62: Paleta de colores

El píxel cambiará automáticamente de color. Si no ocurriese así, habrá

que darle al botón Actualizar de la barra de herramientas de la ventana

principal, para que se produzca tal cambio. Figura 46.

Figura 63: Actualizar



Datos píxel: Cuando se active esta opción, se nos informará de la ubicación

(línea y columna) y de los colores ARGB de cada uno de los píxeles por los

que pase el ratón cuando se encuentre sobre la imagen seleccionada.

Figura 64: Información de cada píxel



Si ahora, se quiere cambiar el color de un píxel, basta con presionar el

botón derecho sobre el píxel que se quiera. Elegimos la única opción que

aparece “Modificar píxel”.

Figura 65: Cambiar color píxel con información del píxel activada

Al presionar esta opción , nos aparecerá la misma ventana que aparecía

con “Modifica píxel”, pero esta vez con los campos de línea y columna

rellenados. (Figura 49)



Figura 66: Cambiar color píxel después de Figura 48



MENÚ UTILIDADES

Figura 67: Menú Utilidades

Generar clave: Genera claves hexadecimales, a partir de la longitud

introducida por el usuario.

La ventana utilizada para ello es la siguiente.

Figura 68: Generar clave



MENÚ VENTANA

Figura 69: Menú ventana

Al abrir imágenes el menú ya presenta la apariencia siguiente.

Figura 70: Menú ventana con imágenes abiertas



Cascada: Organiza las ventanas de imágenes abiertas en forma de cascada.

Figura 71: Imágenes en cascada



Ordenar horizontal: Organiza las imágenes abiertas horizontalmente.

Figura 72: Imágenes ordenadas horizontalmente



Ordenar vertical: Organizar las imágenes abiertas en vertical.

Figura 73: Imágenes ordenadas verticalmente



MENÚ TESTS

Figura 74: Menú Tests

Esta ventana nos permitirá hacer tests sobre una imagen seleccionada

en pantalla.

Se tiene la posibilidad de realizar un histograma, un test de correlación

vertical, horizontal, o diagonal.

Todos los tests: Se realizarán los cuatro tipo de tests y se mostrarán en una

sola pantalla.



Figura 75: Histograma, Correlación vertical, horizontal y diagonal.



MENÚ AYUDA

Figura 76: Menú Ayuda

Figura 77: Acerca de..

BANCO DE PRUEBAS PARA ALGORITMOS DE CRIPTOGRAFÍA … · Los algoritmos se añadirán al programa...

Documents

Transcript of BANCO DE PRUEBAS PARA ALGORITMOS DE CRIPTOGRAFÍA … · Los algoritmos se añadirán al programa...