instituto politÉcnico...

INSTITUTO POLITÉCNICO NACIONAL

ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA

Y ELÉCTRICA

UNIDAD ZACATENCO

DEPARTAMENTO ACADÉMICO DE INGENIERÍA EN

COMUNICACIONES Y ELECTRÓNICA

ACADEMIA DE COMPUTACIÓN

“SISTEMA PARA ENCRIPTAR FIRMAS DIGITALES DE

DOCUMENTOS OFICIALES EN CÓDIGOS QR”

QUE PARA OBTENER EL TÍTULO DE:

INGENIERO EN COMUNICACIONES Y ELECTRÓNICA

P R E S E N T A

Arturo Andrés Martínez Orozco

ASESORES:

Dr. Jesús Jaime Moreno Escobar

M. en C. Beatriz Adriana Jaime Fonseca

Metodológico: M. en C. Genaro Zavala Mejía

Instituto Politécnico Nacional “La técnica al servicio de la patria”

ESIME ZACATENCO Ingeniería en Comunicaciones y Electrónica.

Página ii

Agradecimientos

A mis padres, ¡gracias por enseñarme a volar! ¡Prometo nunca perder el deseo de batir mis alas!

A mi abuela, ¡gracias por el gran ejemplo que me has dado a seguir!

A mi hermana, ¡gracias por llegar e iluminar mi vida!

A mis amigos, ¡gracias por ser los mejores compañeros en esta etapa de mi vida!



Página iii

Glosario de Acrónimos

CAdES - CMS Advanced Electronic Signature (“Firma Electrónica

CMS Avanzada”, en español)

CMS - Cryptographic Message Syntax (“Sintaxis Criptográfica

de Mensaje”, en español)

DSA - Digital Signature Algorithm (“Algoritmo de Firma Digital”,

en español)

FIPS - Federal Information Processing Standard (“Estándar

Federal de Procesamiento de la Información”, en

español)

IDE - Integrated Development Environment (“Ambiente de

Desarrollo Integrado”, en español)

IEC - International Electrotechnical Commission (“Comisión

Internacional Electrotécnica”, en español)

ISO - International Organization for Standardization

(“Organización Internacional para Estandarización”, en

español)

NIST - National Institute of Standards and Technology

(“Instituto Nacional de Estándares y Tecnología”, en

español)

NSA - National Security Agency (“Agencia de Seguridad

Nacional”, en español)

PAdES - PDF Advanced Electronic Signature (“Firma Electrónica

PDF Avanzada”, en español)

PDF - Portable Document Format (“Formato de Documentos



Página iv

Portables”, en español)

PIN - Personal Identification Number (“Número de

Identificación Personal”, en español)

QR - Quick Response (“Respuesta Rápida”, en español)

RS - Reed-Solomon

SHA-1 - Secured Hash Algoritm 1 (“Algoritmo Seguro de Hash

1”, en español)

SIM - Subscriber Identity Module (“Módulo de Identificación

del Subscriptor”, en español)

UML - Unified Modeling Language (“Lenguaje Unificado de

Modelaje”, en español)

XAdES - XML Advanced Electronic Signature (“Firma Electrónica

XML Avanzada”, en español)

XML-Sig - eXtensible Markup Language (“Lenguaje de Marcas

Extensible”, en español)



Página v

Contenido Agradecimientos ............................................................................................................................ii

Glosario de Acrónimos .................................................................................................................. iii

Índice de figuras ............................................................................................................................ ix

Índice de tablas ............................................................................................................................ xii

1. Introducción ........................................................................................................................... 1

1.1 Objetivos ........................................................................................................................ 1

1.1.1 General ....................................................................................................................... 1

1.1.2 Particulares ................................................................................................................. 1

1.2 Planteamiento del Problema ........................................................................................... 1

1.3 Estado del Arte .............................................................................................................. 2

1.3.1 Solución universitaria: DISIMOD ................................................................................ 2

1.3.2 Soluciones Empresariales ........................................................................................... 4

1.4 Justificación ................................................................................................................... 4

2. Análisis del Entorno ............................................................................................................... 6

2.1 Conceptos ...................................................................................................................... 6

2.1.1 Teoría general de un Proceso ...................................................................................... 7

2.1.2 Codificación ............................................................................................................ 8

2.1.3 Códigos QR ............................................................................................................... 18

2.2 Programación .............................................................................................................. 26

2.2.1 Lenguaje de Programación ................................................................................... 26

2.2.2 Paradigmas de Programación............................................................................... 26

2.2.3 Entorno de Desarrollo Integrado ........................................................................... 31

2.3 Bases de Datos .............................................................................................................. 32

2.3.1 Bases de Datos Relacionales ..................................................................................... 33

2.3.2 Lenguaje SQL ........................................................................................................ 34

2.3.3 Sistema de Gestión de Bases de Datos ...................................................................... 34

2.4 Servidores ..................................................................................................................... 39

2.4.1 Tipos de Servidores .............................................................................................. 40

2.4.2 Servidores Web .................................................................................................... 40



Página vi

2.5 Dispositivos Móviles ...................................................................................................... 43

2.5.1 Sistemas Operativos en dispositivos móviles ........................................................... 44

2.6 Comunicaciones ............................................................................................................45

2.6.1 Protocolos ............................................................................................................ 46

3. Aplicación del entorno al sistema propuesto........................................................................ 49

3.1 Programación .............................................................................................................. 49

3.1.1 Paradigma utilizado: POO ........................................................................................ 49

3.1.2 Lenguaje de programación a usar: Java .....................................................................50

3.1.3 IDE seleccionado: Eclipse ..........................................................................................50

3.2 Conceptos ..................................................................................................................... 51

3.2.1 Criptografía utilizada: DES y DSA .............................................................................. 51

3.2.2 Códigos de Barra usados: códigos QR .................................................................... 53

3.3 Modelo Vista Controlador .............................................................................................54

3.3.1 Componente modelo: MySQL ................................................................................... 55

3.3.2 Componente vista: Android ...................................................................................... 56

3.3.3 Componente controlador: Servidor Apache Tomcat ................................................. 57

3.4 Comunicación entre componentes: Wi-Fi...................................................................... 57

4. Diseño y desarrollo del sistema propuesto. .......................................................................... 59

4.1 Objetivo del sistema .................................................................................................... 59

4.2 Casos de uso ................................................................................................................ 60

4.2.1 Administrar usuarios ............................................................................................ 60

4.2.2 Manejar Sesiones .................................................................................................. 67

4.2.3 Firmar Documentos ............................................................................................... 74

4.2.4 Validar Firmas ....................................................................................................... 79

5. Implementación del proyecto ............................................................................................... 81

6. Conclusiones ........................................................................................................................ 82

Anexos ......................................................................................................................................... 83

A. Anexo – Formatos de documentos oficiales ..................................................................... 84

A.1 Formato de Equivalencia de Estudios del IPN .................................................................85

B. Anexo – Códigos de la programación de la Base de Datos ................................................ 86



Página vii

B.1 – Código para crear la base de datos del sistema ............................................................. 87

B.2 – Código para crear la tabla de usuarios .......................................................................... 87

C. Anexo – Códigos de la programación en Android ............................................................. 88

C.1 Código del texto que aparece en la interfaz gráfica del usuario. ..................................... 89

C.2 Código del encabezado que aparece en la interfaz gráfica del usuario. .......................... 90

C.3 Código del pie de página que aparece en la interfaz gráfica del usuario. ........................ 90

C.4 Código de la interfaz gráfica de usuario para el formulario de registro de usuarios. ........ 91

C.5 Código del control para el envío del formulario de registro de usuarios.......................... 95

C.6 Código para crear la interfaz gráfica del formulario de inicio de sesión .......................... 98

C.7 Código para el control del envío de datos para el inicio de sesión. ................................. 100

C.8 Código para el diseño de la interfaz para el formulario de permiso de uso del dispositivo..

........................................................................................................................................... 104

C.9 Código para el control del envío de datos del formulario de permiso de uso del

dispositivo. ......................................................................................................................... 106

C.10 – Código para la creación del menú de opciones para el usuario. ................................. 108

C.11 Código para el control de la selección del usuario en el menú. ..................................... 110

C.12 – Código para la creación de la interfaz de la selección de documento. ....................... 113

C.13 – Código para el control y el envío de la selección del archivo. ..................................... 114

D. Anexo – Códigos de la programación del servidor. .......................................................... 120

D.1 – Código para la conexión a la base de datos de MySQL ............................................... 121

D.2 – Código para realizar las consultas a la base de datos .................................................. 123

D.3 Código para hacer las operaciones sobre la base de datos. ........................................... 125

D.4 – Código que contiene a la entidad Usuario .................................................................. 127

D.5 – Código que contiene a la entidad Dispositivo ............................................................. 131

D.6 – Código que contiene el algoritmo de encriptación DES ............................................. 133

D.7 – Código que contiene la encriptación MD5 .................................................................. 135

D.8 – Código que genera la clave que se mostrará en el código QR. .................................... 136

D.8 – Código que hará el registro en la base de datos. ........................................................ 137

D.9 – Código para el inicio de sesión ................................................................................... 140

D.10 – Código para el permiso de uso del dispositivo en caso de no ser el dueño. ............... 142

D.11 – Código para el cierre de sesión. ................................................................................ 144



Página viii

D.12 – Código para la encriptación de la firma procesada en el servidor .............................. 146

D.13 Código para el algoritmo DSA. .................................................................................... 148

Referencias................................................................................................................................. 151



Página ix

Índice de figuras

Figura 1.1 - Comunicación entre múltiples dispositivos usando DISIMOD ....................................... 3

Figura 1.2 - Pasos mientras se envía un mensaje con DISIMOD ...................................................... 3

Figura 1.3 - Diagrama de casos de uso del Sistema propuesto ....................................................... 5

Figura 2.1 - Estructura del análisis de entorno ............................................................................... 6

Figura 2.2 - Concepto general para la resolución de un problema ................................................... 7

Figura 2.3 - Comparación entre un algoritmo y un programa .......................................................... 7

Figura 2.4 - Esquema de la codificación ......................................................................................... 8

Figura 2.5 - Ejemplo de confidencialidad. ..................................................................................... 10

Figura 2.6 - Ejemplo de autenticidad. ........................................................................................... 10

Figura 2.7 - Proceso para generar una firma digital ....................................................................... 12

Figura 2.8 - Proceso de comprobación de una firma digital .......................................................... 12

Figura 2.9 - Partes del algoritmo SHA-1 ........................................................................................ 13

Figura 2.10 - Código de barras unidimensional ............................................................................. 15

Figura 2.11 - Maxicode .................................................................................................................. 16

Figura 2.12 – DataMatrix .............................................................................................................. 17

Figura 2.13 - Código Azteca .......................................................................................................... 17

Figura 2.14 - PDF417 ..................................................................................................................... 18

Figura 2.15 - Características del código QR ................................................................................... 19

Figura 2.16 - Formación del código QR con nivel H de corrección con capacidad de 196 bytes. ... 22

Figura 2.17 - Estructura del código QR. ......................................................................................... 23

Figura 2.18 - Corrección de la inclinación del código QR .............................................................. 24

Figura 2.19 - Rotación del Código QR .......................................................................................... 24

Figura 2.20 - Códigos QR distorsionados ......................................................................................25

Figura 2.21 - Corrección de la inclinación en los códigos QR .........................................................25

Figura 2.22 - Representación gráfica de la secuencia. ................................................................... 27

Figura 2.23 - Representación gráfica de la selección ..................................................................... 27

Figura 2.24 - Diagrama a bloques de la iteración ......................................................................... 28

Figura 2.25 - Logotipo de Java ...................................................................................................... 31

Figura 2.26 - Logo de Eclipse ........................................................................................................ 32

Figura 2.27 - Logotipo de NetBeans .............................................................................................. 32

Figura 2.28 - Representación simbólica de una base de datos ...................................................... 33

Figura 2.29 - Logotipo de PostgreSQL ......................................................................................... 36

Figura 2.30 - Logo de MySQL ....................................................................................................... 36

Figura 2.31 - Logotipo de Microsoft SQL Server ........................................................................... 38

Figura 2.32 - Logo de Oracle Database ......................................................................................... 38

Figura 2.33 - Modelo cliente/servidor. ........................................................................................... 39

Figura 2.34 - Evolución del ambiente de computación ................................................................. 40



Página x

Figura 2.35 - Logotipo de Apache Tomcat ................................................................................... 42

Figura 2.36 - Logotipo de Oracle Glassfish .................................................................................... 43

Figura 2.37 - Ejemplos de dispositivos móviles .............................................................................. 43

Figura 2.38 - Logotipo del S.O. Android ....................................................................................... 44

Figura 2.39 - Logo del S.O. iOS .....................................................................................................45

Figura 2.40 - Ejemplo de conexión entre internet y varios dispositivos ......................................... 47

Figura 2.41 - Ejemplo de comunicación por Bluetooth ................................................................. 48

Figura 3.1 - Diagrama de los elementos que componen al sistema propuesto ............................. 49

Figura 3.2 - Lenguaje seleccionado para el sistema propuesto: Java .............................................50

Figura 3.3 - IDE seleccionado para el proyecto: Eclipse ................................................................. 51

Figura 3.4 - Proceso de firma para el algoritmo DSA .....................................................................52

Figura 3.5 - Proceso de validación de firma del DSA ..................................................................... 53

Figura 3.6 - Ejemplo de un mensaje codificado y encriptado......................................................... 53

Figura 3.7 - Logo de la librería ZXing .............................................................................................54

Figura 3.8 - Correlación entre el modelo, la vista y el controlador ................................................. 55

Figura 3.9 - El modelo del sistema propuesto ............................................................................... 55

Figura 3.10 - Estadística tomada de la página web http://gs.statcounter.com ............................. 56

Figura 3.11 - S.O. seleccionado para la vista del proyecto: Android ............................................... 57

Figura 3.12 - Servidor seleccionado para el componente controlador: Tomcat ............................. 57

Figura 3.13 - Logotipo del esquema de comunicación: Wi-Fi .........................................................58

Figura 3.14 - Diagrama general del diseño para el sistema propuesto. ..........................................58

Figura 4.1 - Diagrama de casos de uso del Sistema ...................................................................... 60

Figura 4.2 - Diagrama entidad-relación entre el usuario y el dispositivo móvil .............................. 61

Figura 4.3 - Esquema del proceso de insertar usuarios .................................................................. 63

Figura 4.4 - Formulario de registro de usuarios ............................................................................ 64

Figura 4.5 - Diagrama de flujo para el algoritmo de insertar usuarios y dispositivos ..................... 65

Figura 4.6 - Encriptación de llave pública ..................................................................................... 66

Figura 4.7 - Encriptación de llave privada ..................................................................................... 66

Figura 4.8 - Salida para el caso A ................................................................................................. 66

Figura 4.9 - Salida para el caso B .................................................................................................. 67

Figura 4.10 - Salida para el caso C ................................................................................................. 67

Figura 4.11 - Diagrama de proceso de inicio de sesión ................................................................. 69

Figura 4.12 - Formulario para el inicio de sesión ............................................................................ 70

Figura 4.13 - Formulario para préstamo del dispositivo móvil. ...................................................... 70

Figura 4.14 - Algoritmo del servidor para el inicio de las sesiones. ................................................ 72

Figura 4.15 - Menú de opciones para el usuario. ............................................................................ 73

Figura 4.16 - Proceso de cierre de sesión ...................................................................................... 73

Figura 4.17 - Diagrama de flujo para el cierre de sesión ................................................................. 74

Figura 4.18 - Diagrama del proceso de firma................................................................................. 75

Figura 4.19 - Selección del documento a firmar ............................................................................ 76



Página xi

Figura 4.20 - Algoritmo de la encriptación de la firma. ................................................................. 77

Figura 4.21 - Conformación de la firma que se mostrará en el código QR ..................................... 78

Figura 4.22 - Proceso para la firma DSA........................................................................................ 78

Figura 4.23 - Código QR generado con la firma encriptada. .......................................................... 79

Figura 4.24 - Diagrama del proceso de validación ......................................................................... 79

Figura 4.25 - Diagrama que muestra el proceso de validación de una firma con DSA. .................. 80

Figura 4.26 - Mensaje desencriptado mostrando quien firmó el documento ............................... 80



Página xii

Índice de tablas

Tabla 2.1 - Designación en el modo alfanumérico ........................................................................ 20

Tabla 2.2 - Códigos RS con diferentes niveles de restauración ...................................................... 21

Tabla 2.3 - Organización del nivel H con capacidad de 196 bytes .................................................. 21

Tabla 4.1 - Entidad usuario y sus atributos ................................................................................... 62

Tabla 4.2 - Entidad dispositivo y sus atributos ............................................................................. 62

Tabla 4.3 - Entidad dispositivo junto con sus atributos ................................................................ 68



Página 1

1. Introducción

El presente trabajo muestra el desarrollo de un proyecto para la conclusión de la carrera de Ingeniería en Comunicaciones y Electrónica, con especialidad en Computación, de la Escuela Superior de Ingeniería Mecánica y Eléctrica del Instituto Politécnico Nacional de México. Se trata de un software de firma digital para utilizarse en la autenticación de la documentación del Instituto Politécnico Nacional, mediante dispositivos móviles con sistema operativo Android. Este trabajo analiza la especificación y la aplicación del proyecto, buscando presentar el prototipo funcional obtenido al final del mismo.

1.1 Objetivos

1.1.1 General

Desarrollar un software para firmar electrónicamente documentos oficiales.

1.1.2 Particulares

Desarrollar algoritmos para codificar y decodificar una firma digital.

Diseñar una base de datos para el funcionamiento del sistema.

Crear un software que efectúe los procesos del servidor, para la

encriptación y la administración de la base de datos.

Realizar una aplicación para el sistema operativo Android, que genere

códigos QR a partir de un proceso del servidor y sea capaz de leerlos.

Establecer la comunicación de red inalámbrica entre los dispositivos

móviles y el servidor.

1.2 Planteamiento del Problema

Actualmente, el internet es uno de los medios de comunicación más importantes,

si no es que, el más importante. Las computadoras de escritorio y portátiles (o

comúnmente denominadas desktops y notebooks respectivamente), son muy

utilizadas en el intercambio de mensajes y documentos de ciudadanos con



Página 2

empresas de fin comercial y gubernamental. Sin embargo, los nuevos dispositivos

móviles han ganado mucha atención entre los usuarios de internet en los últimos

años, debido a la introducción de la llamada Web 2.0.

El principio de esta Web 2.0 está basado en la inteligencia colectiva, es decir, en la participación de todos los usuarios del internet; el concepto necesita de la capacidad de comunicarse todo el tiempo, capacidad que las aplicaciones de los dispositivos móviles pueden otorgar. [I] No obstante, se necesita de seguridad en ese intercambio de información para confiar que los datos son íntegros y auténticos. Precisamente esos atributos son solucionados en la creación de la herramienta llamada “certificación digital. [II]

La certificación digital es un procedimiento que garantiza la vinculación entre una persona o entidad y una llave pública. De momento, existen varias formas para crear certificados digitales, siendo las más eficientes, aquellas que utilizan sistemas con mucha capacidad de procesamiento como desktops y notebooks. Por el contrario, los dispositivos móviles no poseen ese tipo de capacidad de procesamiento tan robusto y he aquí, la premisa del problema.

1.3 Estado del Arte

1.3.1 Solución universitaria: DISIMOD

Entre las actuales soluciones a este problema, se encuentra el desarrollado por la Universidad de São Paulo en el 2011. Ahí se desarrolló un sistema que toma en cuenta las limitantes de los dispositivos móviles y genera una firma digital funcional; este sistema fue llamado DISIMOD, el cual atiende al acrónimo de “Digital Signature for Mobile Devices” en inglés o “Firma Digital para Dispositivos Móviles” en español.

Para establecer la comunicación del DISIMOD se realiza mediante el protocolo Bluetooh, el cual necesita dos requisitos: conocer los dispositivos en la cercanía así como la existencia de un circuito predeterminado. Una de las limitantes del proyecto es el hecho de que las personas que deseen intercambiar mensajes, deben estar próximos el uno al otro. Esta comunicación se hace con una tecnología basada en el CHAT como se muestra en la figura 1.1.



Página 3

Una vez establecida la conexión del chat entre los dispositivos móviles, éstos podrán realizar intercambio de mensajes, los cuales estarán cifrados. Éste procedimiento se ve en la figura 1.2.

Figura 1.1 - Comunicación entre múltiples dispositivos usando DISIMOD

Figura 1.2 - Pasos mientras se envía un mensaje con DISIMOD

Finalmente, los resultados de las pruebas hechas entre dispositivos móviles, mostraron que el proceso desde que un usuario decide enviar un mensaje, hasta la recepción del mismo, es de un promedio de 45 segundos. Este tiempo es debido a que el proceso de encriptación es complejo para el sistema operativo del dispositivo.



Página 4

1.3.2 Soluciones Empresariales

Hoy en día existen otras técnicas para solucionar esta problemática que se han desarrollado en el ambiente empresarial, entre las cuales se encuentran:

Un certificado digital instalado en la memoria SIM del dispositivo móvil, mediante el cual el usuario puede realizar varias operaciones (pago de impuestos, transacciones, gestiones internas de empresa, identificación para uso de servicios, etc.) con „total seguridad‟, garantizada por la utilización de un código PIN y el envío de mensajes de información cifrada.

Un sistema basado en una plataforma central, la cual es la responsable de realizar todos los procesos, dejando al software de los dispositivos móviles sólo como una interfaz para interactuar con el usuario.

1.4 Justificación

Se pretende dar una propuesta alternativa para la certificación digital que aproveche las capacidades de las herramientas de la Web 2.0, o sea de los dispositivo móviles, utilizando algoritmo de encriptación y desencriptación de firmas digitales y resultando en un nuevo formato de firma digital basado en la estructura de lectura rápida del Código QR. Se desarrollará un sistema integral para lograr la verificación de autenticidad e integridad en el intercambio de archivos electrónicos, pero lo que diferencia este proyecto de las soluciones existentes, es que aprovecharán los dispositivos móviles para codificar la firma digital, eliminando la dependencia de un sistema central. El sistema utilizará un sistema de comunicación mediante la conexión a internet para conectarse con el servidor, con el cual se dividirá las tareas para hacer más eficiente el proceso. El proyecto está pensado para abarcar 4 casos de uso: administrar usuarios, manejar sesiones, firmar documentos, y validar firmas, estos casos interactuarán tanto el servidor, como el usuario. En la figura 1.3 se muestran los citados casos de uso, así como su correlación con los actores.

La potencialidad se encuentra en el creciente número de smartphones en la población, pues el proyecto puede automatizar otros aspectos de la vida diaria. Algunos ejemplos se encuentran en la generación de notas fiscales electrónicas, en las operaciones financieras móviles, en un sistema de voto electrónico, y hasta en sistemas de pago electrónico. En general, cualquier situación en la que se necesite de certificaciones digitales, se puede mejorar dándole una continuidad al proyecto.



Página 5

Figura 1.3 - Diagrama de casos de uso del Sistema propuesto

El proyecto está orientado a ayudar en el esquema de trámites de documentos del Instituto Politécnico Nacional, garantizando la autenticidad e integridad en el envío de documentos electrónicos a través de dispositivos móviles con sistema operativo Android.



Página 6

2. Análisis del Entorno En este capítulo se hace una descripción de aquellos aspectos conceptuales utilizados en el desarrollo del proyecto. Se dividieron las herramientas del entorno en seis secciones, como se observa en la figura 2.1.

Figura 2.1 - Estructura del análisis de entorno

2.1 Conceptos

En esta primera sección se detallan dos mapas mentales de lo que se tomó en

cuenta para el desarrollo del proyecto: un proceso y la codificación. Al ser un

sistema lo que se desarrollará, se debe entender la estructura general de un

proceso, los cuales utilizaremos para la resolución de problemas. Además, como

el proyecto tiene que ver con la seguridad de la información que se transmitirá, se

plantea lo que es la codificación, así como los diversos tipos de codificación de

datos.



Página 7

2.1.1 Teoría general de un Proceso

Un proceso constituye una actividad de conversión cuyo propósito es transformar la entrada en salida en una duración limitada, produciendo un resultado bien definido y previsto. En la figura 2.2 se muestra la estructura general de un proceso, cuya función es que solucione un problema.

Figura 2.2 - Concepto general para la resolución de un problema

Teoría general de un algoritmo

En Informática, el término algoritmo es utilizado para describir un método de solución de problemas adecuado para ser desarrollado como programa de computadoras. [IV] En la figura 2.3 se muestra un comparativo entre un algoritmo y un programa de computadora.

Figura 2.3 - Comparación entre un algoritmo y un programa [IV]



Página 8

Los algoritmos deben cumplir ciertas características, entre las cuales se encuentran:

Deben ser secuenciales, precisos, finitos, estar definidos y ser estructurados.

Descripción de las estructuras de datos.

2.1.2 Codificación

Esencialmente, la codificación es el proceso que permite pasar de un alfabeto

fuente a un alfabeto código. [V] La figura 2.4 muestra esa correspondencia que

existe entre ambos alfabetos: a cada elemento del alfabeto fuente, le corresponde

un elemento del alfabeto código.

Figura 2.4 - Esquema de la codificación [V]

Criptografía

La palabra significa el arte de escribir en códigos y tiene origen griega, es decir, la forma de escribir de información de manera que nadie entienda la información



Página 9

original, la cual es llamada “texto cifrado”. El proceso de ocultación es llamado de “cifrado” y al proceso contrario, “descifrado”. [VI] Estos dos procesos son realizados mediante programas de computadora llamados “cifradores” y “descifradores”. Estos procesos reciben un texto, a ser cifrado o descifrado, y una llave para alcanzar su objetivo. Es importante saber que sin la llave correcta, un texto cifrado no puede ser descifrado por un intruso sin clave. Actualmente tenemos dos tipos de criptografía: la simétrica y la asimétrica.

Simétrica

La criptografía simétrica cifra y descifra informaciones a través de algoritmos que utilizan una llave única, que garantiza la confidencialidad en la transmisión de datos. Como solamente se ocupa una llave en el cifrado y descifrado, la llave debe ser compartida entre las personas interesadas, lo que se conoce como “intercambio de llaves” y debe ser hecha de forma segura.

Asimétrica

Los algoritmos de la criptografía asimétrica operan con dos llaves diferentes, la pública y la privada, que son generadas en el mismo momento y tienen relación entre sí. La llave privada debe ser ocultada por quien generó las llaves, aunque la llave pública puede mantenerse abierta a quien se quiera comunicar con el propietario de la llave privada correspondiente. La creación de ambas llaves elimina el intercambio de llaves, y permite la comunicación entre el remitente y un número n de destinatarios que solo necesitan una copia de la llave pública. Existen dos ramas principales en este tipo de criptografía: el cifrado de llave pública y las firmas digitales, las cuales logran confidencialidad y autenticidad, respectivamente.

La confidencialidad es lograda por el cifrado de llave pública, pues el texto es cifrado con la llave pública del destinatario. De esa forma, nadie puede descifrar el texto, ni siquiera quien cifró el texto, sólo el destinatario que posee la llave privada. La figura 2.5 muestra un ejemplo de la confidencialidad en un intercambio de mensajes: para que Alicia pueda compartir un texto con Beto, ella debe de cifrarlo utilizando la llave pública de Beto. Solamente Beto puede descifrar la información, pues solamente él posee la llave privada correspondiente.



Página 10

Figura 2.5 - Ejemplo de confidencialidad.[VI]

La autenticidad del documento es alcanzada de la siguiente forma: el autor cifra el documento utilizando su llave privada, para de ese modo garantizar su autoría. El resultado es obtenido solamente por el autor porque la llave privada es conocida solamente por él mismo. La figura 2.6 muestra un ejemplo de ello: Si Alice cifra un texto con su llave privada y la envía para alguien más, él podrá descifrar la información porque tiene la llave pública de Alice. El hecho de ser necesario el uso de la llave privada caracteriza algo que sólo el propietario puede hacer.

Figura 2.6 - Ejemplo de autenticidad.



Página 11

Certificación Digital

La certificación digital es la tecnología que provee de mecanismos de seguridad al procesamiento de datos y al intercambio de informaciones entre ciudadanos, gobiernos y empresas, que es realizado mediante las computadoras y el internet; esta tecnología garantiza autenticidad, confidencialidad e integridad de las informaciones electrónicas, y está compuesta por diferentes partes que serán descritas en los siguientes párrafos.

Certificado Digital

Es un documento electrónico que contiene el nombre, un número público exclusivo que es llamado “llave pública” y otros datos que muestran quienes somos para las personas y para los sistemas de información. Cumple con la función de relacionar a una persona con una llave pública [VI] Generalmente contiene los siguientes datos:

Nombre de la persona

Periodo de validez

Llave pública

Nombre y firma de la entidad que firmó el certificado

Número de serie

Firma Digital

Las firmas digitales garantizan la autenticidad, y además de eso la integridad; son el proceso de combinar dos operaciones: la autenticación y la función resumen, llamada también como función hash. [VI] El resumen criptográfico es resultado de una función hash, lo cual puede ser comparado con una huella digital, pues cualquier pequeña modificación hecha al documento, aun siendo sólo un espacio en blanco, resulta en un resumen completamente diferente. La figura 2.7 muestra el proceso para generar una firma digital.



Página 12

Figura 2.7 - Proceso para generar una firma digital

La ventaja de la utilización de los resúmenes es la reducción de tiempo para el proceso de autenticación, pues el tamaño del resumen es siempre menor del tamaño del documento en sí. Para comprobar una firma digital es necesario calcular el resumen criptográfico

del documento y descifrarla con la llave pública del autor. Si son iguales, significa

que la firma es correcta, y en el caso contrario, podría tener alteraciones en el

documento o en la firma, con lo que se comprueba la integridad del texto original.

La figura 2.8 muestra un esquema del proceso de comprobación de una firma

digital.

Figura 2.8 - Proceso de comprobación de una firma digital



Página 13

Hash

El procedimiento para resumir un documento consiste de la función Hash, la cual

crea un pequeño bloque de datos de tamaño fijo, conocido como resumen del

mensaje o valor de hash, a partir del mensaje. Según Silberschatz, las funciones

hash funcionan partiendo un mensaje en bloques de n bits y procesando los

bloques para producir un hash de n bits. Hash necesita ser resistente a los daños

en un mensaje m, esto és, que no debe ser posible encontrar un 𝑚′ ≠ 𝑚 tal que

𝐻 𝑚 = 𝐻 𝑚′ . Ahora, si 𝐻 𝑚 = 𝐻 𝑚′ , sabemos que 𝑚 = 𝑚′, por lo que el

mensaje no fue modificada. Funciones comunes de resumen del mensaje son

MD5, que produce un hash de 18 bits, y SHA-1, que genera un hash de 160 bits.

[VII]

a. MD5

Este algoritmo de resumen fue desarrollado por Ron Rivest, y hasta hace poco era

considerado como el algoritmo hash más seguro; fue cuando surgió el interés

tanto por la fuerza bruta como por el criptoanálisis que empezó a dejarse de

utilizar. El algoritmo toma como entrada un mensaje de longitud arbitraria,

procesándolo en bloques de 512 bits, y entregando como salida un resumen de la

información de entrada de un tamaño de 128 bits. [VIII]

b. SHA-1

El SHA-1 procesa datos de entrada en bloques de 512 bits, generando un resumen de mensaje de 160 bits, lo cual se muestra en la figura 2.9.

Figura 2.9 - Partes del algoritmo SHA-1 [VII]



Página 14

El SHA-1 comienza llenando el mensaje con 1 bit al final, colocando enseguida tantos bits 0 como sean necesarios para que el ancho sea un múltiplo de 512 bits. Posteriormente, al número de 64 bits que contiene el ancho del mensaje antes del llenado, se le aplica un OR en los 64 bits de menor orden. En la figura 12, el mensaje se muestra con un llenado a derecha debido a que el texto va de izquierda a derecha. El SHA-1 siempre llena al final del mensaje, sin importar la orientación que fue utilizada. Durante el cálculo, SHA-1 mantiene variables de 32 bits, H0 a H4, donde va acumulando el hash. Las variables son mostradas en la figura 12 como Hn y son inicializadas a constantes especificadas en el patrón. Ahora se procesa cada uno de los bloques M0 a Mn-1. Para el bloque actual, primero son copiadas las 16 palabras al inicio de un arreglo auxiliar de 80 palabras, Wn, como es mostrado en la figura 12. Después las otras 64 palabras de W se llenan utilizando la fórmula

𝑊𝑖 = 𝑆1 𝑊𝑖−3 𝑋𝑂𝑅 𝑊𝑖−8 𝑋𝑂𝑅 𝑊𝑖−14 𝑋𝑂𝑅 𝑊𝑖−16 16 ≤ 𝑖 ≤ 79 donde Sb(W) representa la rotación circular izquierda de la palabra de 32 bits, W, por b bits. Ahora cinco variables de trabajo, A a E, se inicializan de H0 a H4, respectivamente. Habiendo procesado los primeros bloques de 512 bits, se inicia lo siguiente. El arreglo W es reiniciado desde el nuevo bloque, pero H queda de la forma en la que estaba. Cuando se acaba el bloque, se inicia el siguiente, y así sucesivamente, hasta que los bloques con mensajes de 512 bits se hayan procesado por completo. Cuando se acaba el último bloque, las 5 palabras de 32 bits en el arreglo H son enviadas a la salida como hash criptográfico de 160 bits. [IX] Nuevas versiones de SHA-1 están en desarrollo para hashes de 256, 384 y 512 bits, respectivamente.

Autoridad Certificadora

Entre los campos del certificado digital se encuentra la identificación y la firma de la entidad que lo emitió. La entidad emisora es llamada como Autoridad Certificadora, la cual es la principal componente de una Infra-Estructura de Llaves Públicas y es responsable por la emisión de los certificados digitales. La Autoridad Certificadora permite verificar la autenticidad y la integridad de un certificado. [VI]



Página 15

Códigos de barra

Hay de dos tipos: unidimensionales y bidimensionales.

A) Unidimensionales

El código de barras es un código basado en la representación mediante un

conjunto de líneas paralelas verticales de distinto grosor y espaciado que en su

conjunto contienen una determinada información, es decir, las barras y espacios

del código representan pequeñas cadenas de caracteres. La figura 2.10 muestra

un ejemplo de éstos.

Figura 2.10 - Código de barras unidimensional

B) Bidimensionales

En estos últimos años, se han desarrollado un conjunto de códigos bidimensionales, los cuales permitieron codificar una cantidad mayor de información en menos espacio que lo que era permitido por los códigos de barras unidimensionales. El hecho de poder contener una gran cantidad de información ocupando una superficie pequeña, dio lugar a una rápida aceptación en las empresas privadas generalmente. Estos códigos fueron llamados bidimensionales porque para ser leídos requieren lectores ópticos que puedan leer toda la superficie limitado por el código y no sólo la parte transversal del mismo, pues cada sección transversal es diferente una de la otra.



Página 16

A continuación, se describen algunos de los códigos bidimensionales más utilizados en la actualidad.

Maxicode

El MaxiCode fue desarrollado por la empresa United Parcel Service en 1994 y la figura 2.11 muestra un ejemplo de éstos; es identificado fácilmente debido al “ojo” que está colocado en el centro del código, y además, contiene módulos blancos y negros hexagonales. El MaxiCode puede codificar hasta 100 caracteres en una pulgada cuadrada y su capacidad para corregir errores permite recuperar toda la información inclusive sin 25% del código original.

Figura 2.11 - Maxicode

DataMatrix

La simbología DataMatrix se muestra en la figura 2.12 y fue desarrollado por CiMatrix y, actualmente es una de las más utilizadas en los mercados de circuitos integrados e impresos, debido a su capacidad para codificar hasta 50 caracteres en 3mm2. DataMatrix contiene módulos de datos formados por cuadros blancos y negros y cuatro líneas, dos blancas y dos negras en el perímetro. Puede codificar hasta 3116 dígitos o 2335 caracteres alfanuméricos en un símbolo cuadrado de 144 módulos, utilizando códigos de Reed-Solomon para corregir errores.



Página 17

Figura 2.12 – DataMatrix

Código Azteca

El Código Azteca fue desarrollado en 1995 por Welch Allyn Inc. Y contiene

módulos cuadrados blancos y negros, y en el centro, cuadrados concéntricos.

Existen 32 tamaños diferentes, y pueden almacenar hasta 3067 caracteres, 3832

dígitos o 1914 bytes. Además, el usuario puede seleccionar porcentualmente,

entre 5% y 95%, de nivel de corrección de errores mediante códigos de Reed-

Solomon. Se presenta un ejemplo en la figura 2.13.

Figura 2.13 - Código Azteca



Página 18

PDF417

El código más utilizando anteriormente, era el llamado PDF417, el cual fue

desarrollado por Symbol Technologies en 1990. Puede contener hasta 1850

caracteres de texto, 2710 dígitos o hasta 1108 bytes. Es posible seleccionar entre

9 posibles niveles de corrección de errores mediante códigos de Reed-Solomon,

que permiten recuperar la información perdida. En la figura 2.14 se muestra un

ejemplo de éstos códigos.

Figura 2.14 - PDF417

2.1.3 Códigos QR

Código QR es un código de barras bidimensionales que puede ser fácilmente escaneado utilizando la mayoría de los celulares modernos equipados con cámara. Su acrónimo responde a “Quick Response”, debido a la velocidad de su lectura. El código fue desarrollado por la compañía japonesa Denso Wave en 1994. Inicialmente fue utilizado en la construcción de vehículos para catalogar diferentes partes, hoy el código QR es utilizado en el gerenciamiento de inventario en las industrias. Desde algunos años, están siendo desarrolladas aplicaciones direccionadas para ayudar a los usuarios en la tarea de agregar datos en teléfonos celulares utilizando la cámara fotográfica, como por ejemplo, un link para un sitio de internet externo y redireccionar el navegador del propio celular. El estándar japonés para el código QR fue disponibilizado en enero de 1999 y corresponde al estándar internacional ISO/IEC 18004, y fue aprobado en junio de 2000. Según el sitio de la Denso-Wave, “el código QR es abierto para uso y su patente, por la Denso-Wave, no es practicada”. [X]



Página 19

Su capacidad de almacenamiento es la siguiente:

Numérica - máx. 7089 caracteres

Alfanumérica - máx. 4296 caracteres

Binário (8 bits) - máx. 2953 bytes

Kanji/Kana - máx. 1817 caracteres

Figura 2.15 - Características del código QR

La razón de la importancia de este código es que fue desarrollado basado en las características estructurales de los otros códigos de barras bidimensionales como la alta capacidad de almacenamiento del PDF417, la grande densidad de impresión del DataMatrix y la alta velocidad de lectura del MaxiCode. La figura 2.15 muestra un esquema de esta correlación entre las características de los diferentes códigos y las características estructurales del código QR.

Codificación de los códigos QR

Existen diferentes modos de almacenamiento de datos en los códigos QR, como el modo numérico, el modo alfanumérico, el modo Kanji, y el modo mixto. Por ejemplo, en el modo alfanumérico, existen 45 caracteres, cada uno mapeado con enteros como se muestra en la tabla 2.1.



Página 20

Tabla 2.1 - Designación en el modo alfanumérico [IX]

Se explicará cómo se forma la información de los códigos QR, pero enfocándose solamente en el modo numérico. [IX] En casi todos los modos de caracteres, cada dos o tres caracteres son codificados en binario, y después se comprimen los datos de entrada. Por ejemplo, en la secuencia “01234567” que se supone es la entrada, cada 3 caracteres van a ser codificados en forma binaria de 10 bits, y los restantes 2 caracteres en 7 bits, esto es,

012 = 0000001100 345 = 0101011001

67 = 1000011 La entrada binaria total puede ser expresada como:

0000001100 0101011001 1000011 Después se calcula el ancho máximo total de los datos con

𝐿𝑛 = 10 × 𝐿𝐷/3 + 𝐿𝑑 donde LD es el ancho de los datos de entrada, y Ld es definido por

si 𝐿𝐷 𝑚𝑜𝑑 3 = 0, entonces 𝐿𝑑 = 0 si 𝐿𝐷 𝑚𝑜𝑑 3 = 1, entonces 𝐿𝑑 = 4

si 𝐿𝐷 𝑚𝑜𝑑 3 = 2, entonces 𝐿𝑑 = 7

entonces, calculando,

𝐿𝑛 = 10 × 8/3 + 7 = 33.6666 ≈ 32 De este modo, se observa que los resultados fueron positivos, pues se utilizaron solamente 27 bits, entrando dentro de los 32 bits permitidos. Después se expresará la información en conjuntos de 8 bits, agregando 0‟s al final para satisfacer la condición; sin embargo, se necesita agregar la información del modo y el tamaño de los bloques, que en este caso para designar el modo numérico se utiliza “0001”, y para designar el tamaño del bloque se utiliza “0000001000”. Al



Página 21

final colocamos “0000” para indicar el final de la secuencia. El resultado se muestra a seguir,

Los últimos tres 0‟s fueron agregados para satisfacer la condición de tener conjuntos de 8 bits.

Nivel Longitud n del código (bytes)

Longitud r de Chequeo (bytes)

Código RS (n,k,t)

Función de código tc-md

L M Q H

26 26 26 26

7 10 13 17

(25,19,2) (26,16,4) (26,13,6) (26,9,8)

2c-5d 4c-6d 6c-7d 8c-9d

H 196 130 4x(39,13,13) Y (40,14,13)

13 x 5c

Tabla 2.2 - Códigos RS con diferentes niveles de restauración

Así, es posible seleccionar entre 4 niveles de corrección de errores – los niveles L, M, Q y H, en donde el L recupera 7% de daño, el M 15%, el Q 25% y el H 30%, respectivamente. La secuencia de información es codificada seleccionando códigos RS dependiendo de nuestra selección. En la tabla 2.2 se encuentran ejemplos de los cuatro códigos RS. Los parámetros (n, k, t) de los códigos RS significan que el código tiene un ancho de n bytes, un ancho de datos de entrada de k bits y un ancho de corrección de t bytes. La función de código tc-md significa que el código corrige los errores de tamaño t bytes y detecta errores de tamaño m de bytes.

Datos Información de chequeo

Bloque 1: D1 D2 … D13 Bloque 2: D14 D15 … D26 Bloque 3: D27 D28 … D39 Bloque 4: D40 D41 … D52

Bloque 5: D53 D54 … D65 D66

C1 C2 … C26 C27 C28 … C52 C53 C54 … C78 C79 C80 … C104

C105 C106 … C130 Tabla 2.3 - Organización del nivel H con capacidad de 196 bytes

Para ejemplificar, se usará el último H de 196 bytes, que está compuesto por 4 bloques (39, 13) y un bloque de (40, 14), cada uno capaz de corregir errores de 13 bytes. Los 196 bytes están organizados como se muestra en la tabla 2.3 y en la figura 2.16.



Página 22

Figura 2.16 - Formación del código QR con nivel H de corrección con capacidad de 196 bytes.

Para leer códigos QR se sigue un algoritmo, el cual comienza con una binarización. La binarización es un proceso de reducción de información de la imagen, en la cual sólo persisten dos valores: verdadero y falso. En una imagen digital, estos valores se representan por los valores 0 y 1, y en el caso de los códigos QR, como negro (0) y blanco (1). Una manera simple para separar los valores se muestra a continuación

𝑔 𝑥, 𝑦 = 0 𝑠𝑒 𝑓 𝑥, 𝑦 ≥ 𝑢𝑚𝑏𝑟𝑎𝑙

1 𝑠𝑒 𝑓 𝑥, 𝑦 < 𝑢𝑚𝑏𝑟𝑎𝑙

Existen diversas formas para calcular el umbral adecuado para esta situación, uno de los métodos más utilizados es el método de Otsu, el cual utiliza técnicas estadísticas, para escoger el mejor umbral. Específicamente utiliza la varianza, para medir la dispersión de los niveles de gris.



Página 23

Figura 2.17 - Estructura del código QR.

Posteriormente a la binarización, se utilizan las características estructurales del código QR que ayudan en la corrección de varios problemas, estas características están representadas por diferentes patrones, los cuales se pueden observar en la figura 2.17. El primero de ellos es la inclinación, pues cuando la imagen se captura, a veces aparece girada y requiere una operación de rotación para corregirse. Este problema se resuelve sabiendo que cualquiera que sea la rotación, los padrones de posición que se muestran en la figura 2.18, tienen el mismo tamaño y forma. Se realizan 3 lecturas en diferentes posiciones para percibir las relaciones de las distancias entre los colores blanco y negro, pues en todas las direcciones siempre deberán ser 1:1:3:1:1.



Página 24

Figura 2.18 - Corrección de la inclinación del código QR

Se calcula la distancia basado en las relaciones que serán siempre las mismas. Una vez corregido le problema de la inclinación, se determina el ángulo de rotación, el cual es determinado por los padrones de posicionamiento y utilizando el algoritmo del vecino más próximo. La figura 2.19 muestra un ejemplo de un código QR rotado, así como los elementos que ayudan en la resolución de este problema.

Figura 2.19 - Rotación del Código QR

Otro de los problemas a corregir, es el de la distorsión cuando el código está atado a una superficie curva, o cuando se intenta leerlo de forma inclinado; ejemplos de ello se muestran en la figura 2.20.



Página 25

Figura 2.20 - Códigos QR distorsionados

Para corregir el problema, el código QR tiene padrones de alineamientos dispuestos con un intervalo regular dentro del símbolo. La varianza entre la posición del centro del símbolo y de la posición central actual, se calcula para obtener los mapeamientos corregidos. Esto hará que los símbolos sean legibles Un ejemplo gráfico de la resolución de este problema se encuentra en la figura 2.21, el cual muestra cómo se calcula el centro y cómo se corrige la varianza.

Figura 2.21 - Corrección de la inclinación en los códigos QR

Este conjunto de técnicas es la forma en como se corrigen los problemas posibles en la lectura de éste tipo de códigos.



Página 26

2.2 Programación

Tenemos que, la programación es aquel proceso de diseñar, codificar, depurar y mantener el código fuente de programas computacionales. Éste código fuente se escribe en un lenguaje de programación, y el objetivo de éstos programas es que se comporten de una manera deseada. Todo esto requiere de diferentes herramientas, además del dominio del lenguaje a utilizar, como algoritmos especializados a ciertos casos y la lógica.

2.2.1 Lenguaje de Programación

Es un lenguaje que los programadores usan para comunicar instrucciones a una computadora. Estos lenguajes están diseñados para expresar algoritmos, por lo que deben de cumplir con las características de los mismos, vistas en la sección 2.1.1.1. En la actualidad, existe una variedad de lenguajes de programación, entre los cuales existen algunos que son más conocidos que otros, como por ejemplo, Java, C++, C#, PHP, HTML, Javascript, etc. Cada uno de estos con características y aplicaciones diferentes. La acción de escribir instrucciones para computadoras, utilizando alguno de estos lenguajes, se conoce como programación.

2.2.2 Paradigmas de Programación

Inicialmente, cuando la programación se creó, sólo existía un paradigma para programar, pues las necesidades no eran las mismas que las de hoy en día, pues las necesidades actuales requieren de una mayor velocidad en los programas, una mayor precisión, y una mayor eficiencia. Todo ello, orientó a la creación de nuevos paradigmas de programación

A) Programación Estructurada

Fue el primero de los paradigmas creados; en el año de 1966, C. Boehm y G. Jacopini establecieron el teorema que sería el pilar de la programación estructurada.[XI] Este, demostraba que:

“los algoritmos que eran capaces de computar las Máquinas de Turing eran implementables con sólo dos tipos de reglas o sentencias de control: las sentencias iterativas (mientras se cumpla esto hacer…) y las sentencias condicionales (si esto entonces… si no…).”



Página 27

Utilizando este teorema, la programación estructurada se fundamentó en tres conceptos:

La secuencia, que las instrucciones se ejecutan en una sucesión simple de dos o más operaciones, en el mismo orden en que aparecen en el programa. Gráficamente se representa como se muestra en la figura 2.22.

Figura 2.22 - Representación gráfica de la secuencia [XII].

La selección, que consiste en la bifurcación condicional de una o más operaciones, es decir, el desvío de las operaciones a partir del cumplimiento de una condición. Su representación gráfica se encuentra en la figura 2.23.

Figura 2.23 - Representación gráfica de la selección [XII]



Página 28

La iteración que es la repetición de una operación hasta que sea satisfecha una condición. Su diagrama a bloques se muestra en la figura 2.24.

Figura 2.24 - Diagrama a bloques de la iteración [XII]

Estas estructuras lógicas de control, son combinadas de manera que puedan elaborarse programas que manejen tareas simples y complejos. [XII] Con esto en mente, se buscó una metodología para abordar los problemas, la cual finalmente constó de tres estrategias:

Dividir al programa en “subprogramas” que resuelvan problemas más sencillos.

Limitar las sentencias de control de flujo de información a un número mínimo.

Definir y constreñir el ámbito de uso de los datos usados en el programa. Usando estas estrategias podemos obtener programas que sean fáciles de leer, de comprender, de depurar, y de mantener, para que de esta manera, se pueda trabajar en equipo sobre un mismo programa. Desde la creación de este paradigma de la programación, se han creado varios lenguajes que lo implementan, como Pascal y C, por mencionar a los más conocidos.



Página 29

Pascal

El lenguaje Pascal es un lenguaje de alto nivel y de propósito general, el cual fue desarrollado en 1970 por Niklaus Wirth, sin embargo, recibió su nombre en honor del matemático francés Blaise Pascal, quien fue el inventor de la máquina de calcular mecánica. [XIII] El PASCAL se concibió como un lenguaje de propósito académico, no obstante, posteriormente pasó a ser usado en aplicaciones profesionales de todo tipo, así como también en la ciencia y la tecnología. Es un lenguaje estructurado y los programas escritos con él son fácilmente comprensibles por otros programadores.

C

El lenguaje de programación C fue desarrollado en 1972 por Dennis Ritchie, cuya idea básica era crear un lenguaje de propósito que fuera capaz de realizar muchas tareas reservadas anteriormente a los lenguajes ensambladores pero de una forma más fácil. Este lenguaje tuvo mucho éxito al combinar las ventajas de los lenguajes compilados y los ensambladores; algunas de esas ventajas son las siguientes:

Es de propósito general, pues se puede utilizar para una gran variedad de aplicaciones.

Es fácilmente transportable, pues utiliza librerías para realizar tareas que dependan de la arquitectura de la computadora.

Es de nivel medio, pues compartía las ventajas de los lenguajes ensambladores, así como también permitía el uso de la programación estructurada.

Es modular, pues los programas se podían escribir en módulos por aparte, para finalmente ser enlazadas en un programa entero.

Es conciso, ya que permite ahorrar espacio en disco, tiempo de compilación y tiempo de introducción del programa a la computadora.

Es adecuado para acceder a los recursos del sistema, pues permite controlar con relativa facilidad dispositivos externos.

Aprovechando estas ventajas, es posible escribir programas de cualquier nivel de complejidad utilizando sólo las estructuras básicas de control ya vistas: secuencial, de selección e iterativa. [XIV]



Página 30

B) Programación Orientada a Objetos

Este paradigma, denominado también como POO, está basado en los conceptos de herencia y encapsulamiento de datos; su elemento fundamental es la clase, la cual es un conjunto formado por datos y por operaciones sobre ellos. De esta manera, el acceso a cualquier elemento de este conjunto se realiza a través de un protocolo definido por el programador llamado “interfaz”. Un objeto no es más que la declaración de una variable del tipo de una clase concreta. La herencia es un recurso para definir una nueva clase como una extensión, heredando todos los datos y operaciones, de una clase previamente definida. El encapsulamiento se refiere a que los datos y operaciones de un objeto no son accesibles directamente por un subprograma externo al objeto, sino que deben de solicitarse mediante la interfaz de ese objeto. Este paradigma de programación tiene también sus propias metodologías para obtener la descomposición en objetos del problema que se pretende abordar. Una de las más conocidas es el diseño OMT (Objects Modelling Technique) que está bien fundamentado y posee gran aceptación en Ingeniería de Software. [XI] Algunos lenguajes de POO son C++, Delphi, C# o Java.

Java

Java es un lenguaje independiente de la plataforma, por lo que sus programas pueden ser ejecutados en cualquier sistema sin cambios, hecho logrado utilizando un formato especial para los programas compilados en Java, llamado “byte-code”, el cual puede ser leído y ejecutado por cualquier computadora que posea un intérprete de Java. Este intérprete debe ser desarrollado especialmente para el sistema en el que correrá. Fue en mayo de 1995, que Sun Microsystems anunció oficialmente a Java, el nuevo lenguaje de programación que tenía como ventajas:

Ser seguro.

Se aprende con facilidad.

Orientado a objetos.

No bloquea el sistema.

Aplicaciones para comunicación en red.

No tiene aritmética de apuntadores.

Independiente de la plataforma.



Página 31

La figura 2.25 muestra el logotipo de este lenguaje de programación.

Figura 2.25 - Logotipo de Java

C#

C# (leído “C Sharp”) es un lenguaje de programación orientado a objetos. Fue creado por Microsoft para su plataforma .NET, y aunque esta plataforma pueda soportar aplicaciones en otros lenguajes de programación, C# se creó específicamente para .NET, adecuando todas sus estructuras a las características y capacidades de dicha plataforma. [XV]

2.2.3 Entorno de Desarrollo Integrado

Es un programa informático que tiene herramientas que ayudan a la programación, el cual puede dedicarse en exclusiva a un solo lenguaje de programación o bien, utilizarse para varios. Este entorno ha sido empaquetado como un programa de aplicación, que consiste de un editor de código, un compilador, un depurador y un constructor de interfaz gráfica. Algunos ejemplos son el Eclipse, NetBeans y MonoDevelop, los cuales son compatibles con múltiples lenguajes de programación.

Eclipse

Eclipse es un IDE que puede ser usado para desarrollar software en cualquier lenguaje de programación. Al principio, era un substituto patentado del Visual Age para Java, de la IBM, pero tenía su código fuente abierto en noviembre de 2001. Actualmente, Eclipse es controlado por una organización sin fines lucrativos



Página 32

independiente, llamada Eclipse Foundation. Posee una cantidad considerable de seguidores dentro de la comunidad universitaria, donde es utilizado para clases de programación y proyectos orientados a objetos. [XVI] La figura 2.26 muestra el logotipo de este IDE.

Figura 2.26 - Logo de Eclipse

NetBeans

NetBeans es un IDE poderoso, útil, extensible, abierto a cualquier lenguaje de programación y gratuito. Permite complementar las habilidades del programador haciéndolas más efectivas. Fue desarrollado en el lenguaje de programación Java, el cual, es el lenguaje más desarrollado en este IDE. MicroSystems fundó el proyecto de código abierto NetBeans en junio de 2000 y continúa siendo el patrocinador principal de los proyectos. [XVII] La figura 2.27 representa el logo de NetBeans.

Figura 2.27 - Logotipo de NetBeans

2.3 Bases de Datos

Al estar hoy en día en la Sociedad de la Información, las necesidades de almacenamiento, gestión y transmisión de grandes cantidades de datos, información acerca de los mismos, y todo tipo de operaciones sobre ellos, ha aumentado, y solamente las computadoras poseen esa clase de capacidad. Es



Página 33

por esa razón que hay que conocer el concepto de las Bases de Datos, las cuales, intuitivamente son un fondo común de información almacenada en una computadora para el acceso a la misma. Sin embargo, esta definición se refiere más bien a un sistema de gestión de base de datos; la definición formal, queda de la siguiente forma: “una base de datos está constituida por una instancia de un esquema lógico junto con las instancias de los datos operativos que dicho esquema organiza”. [XVIII] Esta definición es más abstracta y está más ajustada al concepto de base de datos, esto se puede ver más fácilmente en el ejemplo; una base de datos de gestión docente universitaria estaría formada por el esquema lógico que organiza los ítems básicos profesores, grupos, aulas, clases, etc, junto con los datos concretos de profesores, grupos, aulas, clases, etc. La figura 2.28 muestra la representación simbólica de una base de datos.

Figura 2.28 - Representación simbólica de una base de datos

2.3.1 Bases de Datos Relacionales

El modelo relacional para la gestión de una base de datos es un modelo de datos basado en la lógica de predicados y en la teoría de conjuntos. Después de ser postuladas sus bases en 1970 por Edgar Frank Codd, de los laboratorios IBM en San José (California), no tardó en consolidarse como un nuevo paradigma en los modelos de base de datos. El concepto en el que se basa es el de “relaciones”, así como su uso. Estas relaciones podrían considerarse en forma lógica como conjuntos de datos llamados “tuplas”. Pese a que ésta es la teoría de las bases de datos relacionales creada por Codd, la mayoría de veces se conceptualiza cada relación como si



Página 34

fuese una tabla que está compuesta por registros (cada fila de la tabla sería un registro o tupla), y columnas (también llamadas campos). [XVIII]

2.3.2 Lenguaje SQL

SQL es el lenguaje estándar para trabajar con bases de datos relacionales y es soportado prácticamente por todos los productos en el mercado y responde al nombre de “Structured Query Languaje”. Este lenguaje fue desarrollado en IBM Research a principios de los años setenta; sin embargo, fue implementado por primera vez a gran escala en un prototipo de IBM llamado System R, y posteriormente en numerosos productos comerciales de IBM y de muchos otros fabricantes. En un principio, este lenguaje fue diseñado para ser específicamente un "sublenguaje de datos". Sin embargo, con la incorporación en 1996 de la característica de PSM (Módulos Almacenados Persistentes) al estándar, SQL se convirtió, en términos computacionales, en un lenguaje completo (incluyendo instrucciones como CALL, RETURN, SET, CASE. IF, LOOP, LEAVE, WHILE y REPEAT, así como diversas características relacionadas como las variables y los manejadores de excepciones). Como consecuencia, ya no hay necesidad de combinar SQL con algún lenguaje "anfitrión" distinto para desarrollar una aplicación completa. Otra de sus características es el manejo del álgebra y el cálculo relacional que permiten efectuar consultas, esto con el propósito de recuperar de forma sencilla información.

2.3.3 Sistema de Gestión de Bases de Datos

Así, para administrar nuestras bases de datos existen los sistemas de gestión de bases de datos, los cuales son un conjunto de elementos software con capacidad para definir, mantener y utilizar una base de datos. [XVIII] Estos programas son capaces de proveer las siguientes operaciones fundamentales:

Crear, modificar, eliminar y obtener la estructura asociada al esquema lógico de una base de datos.

Instanciar datos operativos en una base de datos, modificar dichas instancias, eliminarlas y recuperarlas bajo diferentes criterios de búsqueda.

En el mercado existen diferentes productos, cada uno con sus propias ventajas y desventajas. Comúnmente son clasificados por el factor económico en sistemas libres y en sistemas no libres, de los cuales se indicarán los más conocidos.



Página 35

A) Sistemas libres

Son sistemas creados a partir de software libre, es decir, se refiere a la libertad de los usuarios para ejecutar, copiar, distribuir, estudiar, modificar el software y distribuirlo modificado. El software libre comúnmente está disponible gratuitamente, o al precio de costo de la distribución a través de otros medios; sin embargo no es obligatorio que sea así, por lo tanto no hay que asociar software libre a "software gratuito”, ya que, conservando su carácter de libre, puede ser distribuido. Tampoco debe confundirse software libre con "software de dominio público”, pues éste es aquél que no requiere de licencia, ya que sus derechos de explotación son para toda la humanidad, porque pertenece a todos por igual. Una de las licencias más utilizadas es la Licencia Pública General de GNU (GNU GPL). El autor conserva los derechos de autor (copyright), y permite la redistribución y modificación bajo términos diseñados para asegurarse de que sea imposible crear un producto con partes no licenciadas GPL: el conjunto tiene que ser GPL. [XIX] Aproximadamente el 60% del software licenciado como software libre emplea una licencia GPL.

PostgreSQL

PostgreSQL es un SGBD relacional orientado a objetos y libre, publicado bajo la licencia BSD, la cual tiene menos restricciones en comparación con otras como la GPL estando muy cercana al dominio público. La licencia BSD al contrario que la GPL permite el uso del código fuente en software no libre. El desarrollo de PostgreSQL es dirigido por una comunidad de desarrolladores que trabajan de forma desinteresada, altruista, libre y/o apoyados por organizaciones comerciales. Dicha comunidad es denominada el PGDG (Postgre SQL Global Development Group). [XX] La figura 2.29 muestra el logotipo de PostgreSQL.



Página 36

Figura 2.29 - Logotipo de PostgreSQL

MySQL

MySQL es un sistema de gestión de bases de datos relacional, multihilo y multiusuario, desarrollado por Oracle Corporation como software libre en un

esquema de licenciamiento dual. Por un lado se ofrece bajo la GNU GPL para cualquier uso compatible con esta licencia, pero para aquellas empresas que quieran incorporarlo en productos privativos deben comprar a la empresa una licencia específica que les permita este uso. La figura 2.30 representa el logotipo de este sistema gestor de base de datos.

Figura 2.30 - Logo de MySQL

En sus inicios, MySQL carecía de elementos considerados esenciales

como integridad referencial y transacciones. No obstante, atrajo a los

desarrolladores de páginas web con contenido dinámico, justamente por su

simplicidad. Poco a poco los elementos de los que carecía MySQL están siendo

incorporados tanto por desarrollos internos, como por desarrolladores de software

libre. [XXI]



Página 37

Entre las características disponibles en las últimas versiones se destacan:

Amplio subconjunto del lenguaje SQL.

Disponibilidad en gran cantidad de plataformas y sistemas.

Posibilidad de selección de mecanismos de almacenamiento que ofrecen

diferente velocidad de operación, soporte físico, capacidad, distribución

geográfica, transacciones...

Transacciones y claves foráneas.

Conectividad segura.

Replicación.

Búsqueda e indexación de campos de texto.

B) Sistemas no libres

Son sistemas creados a partir de software licenciado, es decir, se refiere a que para ejecutar, copiar, distribuir, estudiar, modificar el software y distribuirlo modificado, se debe de pagar por los derechos de licencia a la empresa a la cual le pertenezcan. Además, generalmente es software que no se puede conseguir gratuitamente.

Microsoft SQL Server

Microsoft SQL Server es un sistema para la gestión de bases de datos producido por Microsoft, a quien además le pertenece la licencia, basado en el modelo relacional. Sus lenguajes para consultas son T-SQL y ANSI SQL. [XXII] Entre sus características se encuentran:

Soporte de transacciones.

Mantenimiento de procedimientos almacenados.

Inclusión de un entorno gráfico de administración, que permite el uso

de comandos DDL y DML.

Permite trabajar en modo cliente-servidor.

Admite administrar información de otros servidores de datos.

La figura 2.31 muestra el logotipo de este producto.



Página 38

Figura 2.31 - Logotipo de Microsoft SQL Server

Oracle

Oracle es un sistema gestor de base de datos objeto-relacional (o ORDBMS por el

acrónimo en inglés de Object-Relational Data Base Management System),

desarrollado por Oracle Corporation. La figura 2.32 representa el logotipo de este

sistema gestor de base de datos.

Figura 2.32 - Logo de Oracle Database

Se considera a Oracle como uno de los sistemas de bases de datos más

completos, cuyas características incluyen:

Transaccional,

Estabilidad,

Escalabilidad y

Multiplataforma.



Página 39

Su dominio en el mercado fue casi total recientemente, pues tiene como

competencia a Microsoft SQL Server, PostgreSQL, MySQL o Firebird.

Las últimas versiones de Oracle han sido certificadas para poder trabajar

bajo GNU/Linux.

2.4 Servidores

Un servidor es un proceso que proporciona los servicios solicitados por los clientes. Un cliente es un proceso que solicita servicios específicos a los proceso de un servidor. Estos dos conceptos son utilizados en lo que se denomina el “modelo cliente/servidor” el cual sirve para el desarrollo de sistemas computarizados. Cuando los procesos cliente y servidor residen en dos o más computadoras independientes en una red, el servidor puede proporcionar servicios a más de un cliente. Además, un cliente puede solicitar servicios a varios servidores en la red sin importar la ubicación y las características físicas de la computadora en la que reside el proceso servidor, pues es la red la encargada de enlazar los servidores con los clientes, y la cual proporciona el medio a través el cual los clientes y los servidores se comunican. [XXIII] La figura 2.33 muestra un esquema del modelo cliente/servidor.

Figura 2.33 - Modelo cliente/servidor.

El panorama contemporáneo de la computación, está basado generalmente en una red que vincula varias computadoras. Los usuarios de hoy demandan acceso para analizar y tomar decisiones, además de que incrementan su productividad al rediseñar los procesos de negocios básicos en sus corporaciones. Esta demanda cada vez más creciente de compartir recursos dentro de ese intenso ambiente de comunicaciones, ha preparado la escena para este modelo. La figura 2.34 resume las cuatro etapas de la evolución de los sistemas de información de la



Página 40

infraestructura mainframe a la infraestructura basada en la PC requerida para la computación cliente/servidor.

Figura 2.34 - Evolución del ambiente de computación

2.4.1 Tipos de Servidores

Generalmente los servidores están clasificados dependiendo del tipo de servicio que den al usuario, estos pueden ser para envío de correos, telefonía, de acceso remoto, de administración de bases de datos, web y seguridad, entre otros.

2.4.2 Servidores Web

Se dice que los servidores Web, son el software necesario para correr sitios Web, intranets y extranets. Sus principales características se ven relacionadas a la ubicación y administración de las páginas web almacenadas, pues el servidor ubica las páginas solicitadas por los clientes, traduciendo la dirección URL en una dirección física. Posteriormente, envía al cliente a la página solicitada. Además, los servidores Web pueden tener herramientas, como dar soporte al protocolo FTP para la transferencia de archivos, motores de búsqueda y programas de indexación, además de tener capacidades para guardar la información del visitante al sitio Web. [XXIV]



Página 41

Entre los servidores más populares actualmente se encuentran Apache Tomcat y Glassfish.

Esquemas de petición

El protocolo HTTP define 8 métodos para señalar la acción que se quiera realizar sobre la página Web indicada. Este recurso va a representar, ya sea si es un dato pre-existente o un dato dinámico, lo que el servidor esté programado a hacer con él, y generalmente generan una respuesta del servidor. Los esquemas de petición más utilizados son el GET y el POST.

A) GET

Este esquema pide una imagen del recurso solicitado. Por razones de seguridad no debe ser utilizado en programas que produzcan algún cambio complejo en el sistema ya que envía información a través de la URI agregando parámetros a la ruta URL.

B) POST

Para este tipo de esquema los datos que serán enviados al servidor se incorporan al cuerpo de la petición utilizando las cabeceras HTTP asignadas dependiendo del tipo de petición. Usualmente son utilizados en el envío de formularios web, debido a que los datos son cifrados para que su envío al servidor sea de una forma más segura.

Sockets

Un socket es un punto de conexión entre procesos, diseñado especialmente para su uso en redes de ordenadores. Permiten tanto el envío como la recepción de información, y pueden residir en ordenadores diferentes. [XXV] Existen diferentes tipos, entre los cuales podemos encontrar:

1. Datagrama, el cual se basa en el Protocolo de Datagrama de Usuario. 2. Datos en serie, el cual está basado normalmente en el Protocolo de Control

de Transmisión. 3. Sin formato, el cual permite el acceso a las comunicaciones entre sockets a

bajo nivel.



Página 42

Tomcat

Apache Tomcat funciona como un contenedor de „servlets‟ desarrollado bajo el proyecto Jakarta de la Apache Software Foundation. Soporta las especificaciones de los „servlets‟ y de las Java Server Pages (JSP) de Sun Microsystems. Este servidor es mantenido y desarrollado por la Apache Software Foundation y voluntarios Independientes. Los usuarios disponen de libre acceso a su código fuente debido a que se encuentra con licencia GNU GPL. Actualmente, este servidor utiliza el contenedor de servlets Catalina. La figura 2.35 muestra el logotipo de este servidor.

Figura 2.35 - Logotipo de Apache Tomcat

Glassfish

GlassFish es un servidor de aplicaciones de software libre desarrollado por Sun Microsystems, actualmente adquirida por Oracle Corporation, que implementa las tecnologías definidas en la plataforma Java EE y permite ejecutar aplicaciones que siguen esta especificación. La versión comercial es denominada Oracle GlassFish Enterprise. Es gratuito y de código libre, se distribuye bajo un licenciamiento dual a través de la licencia CDDL y la GNU GPL. La figura 2.36 muestra el logotipo de este servidor.



Página 43

Figura 2.36 - Logotipo de Oracle Glassfish

2.5 Dispositivos Móviles

Se le llama dispositivo móvil se a aquél aparato pequeño, que tiene capacidades de procesamiento, con conexión a una red y con memoria limitada; generalmente son diseñados específicamente para una función, pero pueden llevar a cabo otras funciones. Existen una gran variedad de dispositivos móviles: reproductores de audio, GPS, teléfonos móviles, PDAs, Tablet PCs, entre otros. En la figura 2.37 se muestran algunos ejemplos de dispositivos móviles actuales.

Figura 2.37 - Ejemplos de dispositivos móviles



Página 44

2.5.1 Sistemas Operativos en dispositivos móviles

Existen varias de opciones entre las cuales se puede seleccionar un Symbian, un BlackBerry OS, un Windows Mobile, un iPhone OS y un Android. El uso de uno sistema operativo u otro, determina las capacidades multimedia de los dispositivos, así como su forma de interactuar con el usuario.

Android

Android es un sistema operativo móvil basado en Linux, el cual es desarrollado por la Open Handset Alliance, la cual es liderada por Google. Fue desarrollado inicialmente por Android Inc., una firma comprada por Google en 2005. Tiene una gran comunidad de desarrolladores escribiendo aplicaciones para extender la funcionalidad de los dispositivos. A la fecha, se han sobrepasado las 700.000 aplicaciones disponibles para la tienda de aplicaciones oficial de Android: Google Play. Los programas están escritos en el lenguaje de programación Java. La figura 2.38 contiene el logotipo del sistema operativo Android.

Figura 2.38 - Logotipo del S.O. Android

iPhone OS

iOS es un sistema operativo móvil de la compañía Apple. Originalmente fue desarrollado para el iPhone, siendo después usado en dispositivos como el iPod Touch, iPad y el Apple TV.



Página 45

La interfaz de usuario de iOS está basada en el concepto de manipulación directa, usando gestos multitáctiles. La interacción con el sistema operativo incluye gestos como deslices, toques, pellizcos, los cuales tienen definiciones diferentes dependiendo del contexto de la interfaz. iOS es un sistema operativo Unix. La figura 2.39 muestra el logo de este sistema operativo.

Figura 2.39 - Logo del S.O. iOS

2.6 Comunicaciones En general, a partir del punto de vista de la computación, la comunicación debe ser, al menos, entre dos partes. Estas partes establecen una conversación o sesión a través de las redes, requiriendo un acuerdo previo en relación a la forma de:

establecer la comunicación

formato de los datos

velocidad de transmisión de los datos

direcciones.

numeración de los paquetes para mantener el orden para el envío y recepción de los mismos.

Otros mecanismos Además, es posible que se incorporen sistemas de control por software a cada uno de los dispositivos de la red, el cual está organizado en capas o layers en los cuales se agrupan "especializaciones", de la secuencia de tareas a realizar. Al conjunto de capas y protocolos se le denomina arquitectura de red.



Página 46

La estructura general de una red de comunicaciones, se forma por:

Nodo, el cual es la localización física de un proceso.

Enlace, el cual es el vínculo entre dos nodos.

Protocolo

2.6.1 Protocolos

Los protocolos de comunicaciones hacen posibles las comunicaciones. Las compañías y organizaciones de todos los tamaños utilizan protocolos de comunicaciones. Al igual que los estándares son importantes para la creación de sistemas de computación y de bases de datos, los protocolos establecidos ayudan a asegurar las comunicaciones entre computadoras de diferentes tipos y fabricantes. Muchos protocolos cuentn con capas de estándares y procedimientos. El modelo de interconexión de sistemas abiertos (OSI) se utiliza como un modelo estándar para la arquitectura de redes y cuenta con el apoyo del International Standards Committee.[XXVI] Existen diversos protocolos entre los cuales se encuentran TCP/IP, SNA y Ehernet.

Red inalámbrica

Una red inalámbrica transporta datos de un dispositivo a otro sin el uso de cables. Las redes de todos tamaños, ya sean PANs, LANs o WANs, pueden emplear tecnología inalámbrica, como señales de radio, microondas y luz infrarroja. [XXVII] La principal ventaja de las redes inalámbricas es la movilidad. Los dispositivos inalámbricos no están sujetos a cables de modo que las estaciones de trabajo operadas con baterías se trasladan con facilidad de una habitación a otra o incluso al exterior. Con las redes inalámbricas no se puede observar un cableado complicado y es mucho menos probable que un exceso de sobrevoltaje pase por los cables y dañe las estaciones de trabajo. [XXVII] Entre las tecnologías más populares para las redes inalámbricas se encuentran Wi-Fi, Bluetooth, WiMAX y Zigbee.

A) Wi-fi

Wi-Fi es una tecnología que permite que una gran variedad de equipos informáticos (ordenadores, impresoras, discos duros, cámaras, etc) puedan interconectarse sin necesidad de utilizar cables. La aplicación principal que está



Página 47

teniendo Wi-Fi en la actualidad es la de permitir que varios ordenadores de casa o de la oficina puedan compartir el acceso a internet (de ADSL o cable). No obstante, esta tecnología permite crear una red entre los distintos equipos para compartir todos sus recursos. [XXVIII] La figura 2.40 muestra un ejemplo de la conectividad entre diversos dispositivos con internet.

Figura 2.40 - Ejemplo de conexión entre internet y varios dispositivos

Una de las principales ventajas de Wi-Fi es que utiliza el mismo protocolo que internet (protocolo TCP/IP). Este protocolo lo utilizan también las redes locales de cable, por lo que interconectar una red Wi-Fi con internet o con una red local cableada es bastante simple.

B) Bluetooth

Bluetooth es una tecnología de red inalámbrica de corto alcance diseñada para hacer sus propias conexiones entre los dispositivos electrónicos, sin cables ni ninguna acción directa del usuario. Las redes Bluetooth se forman automáticamente cuando dos o más dispositivos Bluetooth quedan al alcance uno del otro. Una red Bluetooth también se denomina piconet. Para formar una red, un dispositivo Bluetooth busca otros dispositivos Bluetooth a su alcance. Cuando detecta otro dispositivo, suele poder transmitir, por ejemplo entre una impresora,



Página 48

una PC o un teléfono celular. Antes de intercambiar datos, los usuarios de dos dispositivos Bluetooth deben intercambiar identificaciones, o PIN. Una vez intercambiadas las identificaciones, los dos dispositivos Bluetooth forman un par confiable. Las comunicaciones futuras entre estos dos dispositivos no requieren que se vuelva a introducir la identificación. [XXVII] La figura 2.41 representa un ejemplo de comunicación entre varios dispositivos utilizando Bluetooth.

Figura 2.41 - Ejemplo de comunicación por Bluetooth



Página 49

3. Aplicación del entorno al sistema propuesto.

En este capítulo se hace una explicación de cómo fueron aplicados los aspectos conceptuales del entorno en el desarrollo del proyecto. Recordando cómo fueron divididas las secciones, tenemos que son seis, las cuales se pueden observar en la figura 3.1.

Figura 3.1 - Diagrama de los elementos que componen al sistema propuesto

3.1 Programación

Al ser un sistema computacional, la elección del esquema de programación, así como del lenguaje a utilizar es elemental, por lo que es lo primero que se analiza.

3.1.1 Paradigma utilizado: POO

Los paradigmas vistos en el capítulo dos, fueron la programación estructural, y la programación orientada a objetos. Cada paradigma tiene sus ventajas y desventajas, pero aquél que permite utilizar técnicas como la abstracción, la herencia, el acoplamiento y el encapsulamiento, es el paradigma orientado a



Página 50

objetos. Éstas técnicas son importantes en el desarrollo del sistema propuesto, debido a que está orientado a atender a varios usuarios a la vez, por lo que es necesario abstraer nuestras identidades en objetos que se puedan encapsular y que, de esa forma, sean más fácilmente transportables entre una capa y otra. Así, en base a que las ventajas de este tipo de paradigma son las necesarias para el óptimo diseño del sistema propuesto, se tomó la decisión de hacer uso de la programación orientada a objetos.

3.1.2 Lenguaje de programación a usar: Java

Una vez elegido el paradigma de programación, lo siguiente a decidir es el lenguaje de programación. En el capítulo anterior, se analizaron dos de los lenguajes de programación orientados a objetos, los cuales son Java y C#. Cada uno de estos lenguajes tiene sus ventajas y desventajas, que los hace diferenciarse bastante y su utilización depende del tipo de aplicación que se realizará. Algo que se consideró importante, es la transportabilidad del sistema propuesto, característica que C# no cumple, debido a que está orientado a funcionar en sistemas de Microsoft. Por el contrario, Java está orientado a funcionar en cualquier sistema donde se encuentre instalado el JRE, por lo que se seleccionó a Java como el lenguaje a usar. La figura 3.2 muestra un esquema que conforma el núcleo del sistema propuesto, la cual contiene el logo de Java, así como a su mascota “Duke”, junto a una representación de lo que es la programación.

Figura 3.2 - Lenguaje seleccionado para el sistema propuesto: Java

3.1.3 IDE seleccionado: Eclipse



Página 51

Junto con la elección del lenguaje de programación a utilizar, viene la decisión de cual Ambiente de Desarrollo Integrado usar para desarrollar el sistema propuesto. Así, entre la variedad de IDEs existentes, se optó por Eclipse, debido a la flexibilidad de programación y de recursos que ofrece. La figura 3.3 muestra el esquema del núcleo del proyecto, pero con la diferencia de que se le añade el logotipo del IDE seleccionado.

Figura 3.3 - IDE seleccionado para el proyecto: Eclipse

3.2 Conceptos

Para esta sección, los conceptos utilizados para el proyecto son dos: la criptografía y los códigos de barra.

3.2.1 Criptografía utilizada: DES y DSA

Se utilizó una combinación de ambos tipos de encriptaciones: la simétrica y la asimétrica. En la parte de la encriptación simétrica se utilizará el Estándar de Encriptación de Datos (DES) y en la otra parte de la encriptación asimétrica, se usó el Algoritmo de Firma Digital (DSA).



Página 52

A) Encriptación simétrica – DES

Data Encryption Standard (DES) es un algoritmo de cifrado, cuyo uso se ha propagado ampliamente por todo el mundo. El algoritmo fue controvertido al principio, debido a sus elementos de diseño clasificados, como una longitud de clave relativamente corta. Esto ocasionó que el DES fuera sometido a un intenso análisis académico y con lo que se inició el concepto moderno del cifrado por bloques y su criptoanálisis. Actualmente, DES se considera inseguro para muchas aplicaciones, debido a que las claves de DES se han roto en menos de 24 horas por su corta longitud. Así, se decidió utilizar este algoritmo en combinación con el algoritmo de firma digital, para que entre ambos se refuercen las debilidades de cada uno.

B) Encriptación asimétrica - Firma Digital – DSA

DSA es el algoritmo de firma digital, el cual es un estándar para firmas digitales. Fue un Algoritmo propuesto por el Instituto Nacional de Normas y Tecnología de los Estados Unidos y fue publicado el 30 de agosto de 1991; este algoritmo sirve para firmar y no para cifrar información. Una desventaja de este algoritmo es que requiere mucho tiempo de cómputo. El algoritmo consiste en obtener un resumen del documento y firmarlo usando la llave privada del autor. Este proceso se puede observar en la figura 3.4.

Figura 3.4 - Proceso de firma para el algoritmo DSA

El siguiente proceso es la validación de la firma digital, el cual se realiza utilizando la llave pública de quien lo firmó, obteniendo el resumen del documento firmado. Se compara el resumen obtenido, junto con el resumen del documento original, y si ambos son iguales, significa que el documento no sufrió modificación alguna y se encuentra íntegro. La figura 3.5 muestra gráficamente este proceso.

http://es.wikipedia.org/wiki/Algoritmo

http://es.wikipedia.org/wiki/NIST

http://es.wikipedia.org/wiki/30_de_agosto

http://es.wikipedia.org/wiki/1991



Página 53

Figura 3.5 - Proceso de validación de firma del DSA

3.2.2 Códigos de Barra usados: códigos QR

La forma en que se representará la firma digital será la de los códigos QR, pues se ha visto que tienen una gran variedad de aplicaciones, que para el caso del sistema propuesto, muchas de las características de estos códigos serán de utilidad, como su rapidez de lectura. Es además, una forma de codificación de los códigos de manera que no cualquier persona sea capaz de leer el mensaje guardado en ellos. A manera de ejemplo, la figura 3.6 contiene un mensaje doblemente codificado, debido a que en primera instancia, el mensaje contenido en el código no se entiende a simple vista, sino que se requiere de una aplicación que sea capaz de traducirlo. En segunda instancia, no cualquier aplicación será capaz de descifrar el verdadero mensaje, sino que únicamente la aplicación del sistema propuesto es capaz de traducirlo correctamente.

Figura 3.6 - Ejemplo de un mensaje codificado y encriptado.



Página 54

Librería ZXing.

Para la codificación y decodificación, se utiliza una librería llamada “ZXing” la cual se encuentra en su versión 2.0. El criterio de selección de esta librería fue su licencia libre, así como la flexibilidad para integrarse al proyecto. La figura 3.7 muestra el logo de esta librería.

Figura 3.7 - Logo de la librería ZXing

3.3 Modelo Vista Controlador

El Modelo Vista Controlador (MVC) es un patrón de abstracción de desarrollo de software que separa los datos de una aplicación, la interfaz de usuario, y la lógica de negocio en tres componentes distintos: el modelo, la vista y el controlador. Básicamente, los componentes se establecen de la siguiente manera:

Modelo: es la representación de la información o los datos con los cual el

sistema opera. Generalmente, los sistemas utilizan un Sistema de Gestión de Base de Datos para administrar los datos.

Vista: generalmente es la interfaz de usuario.

Controlador: es el que responde a eventos, acciones del usuario, e invoca peticiones al modelo y, posiblemente, a la vista.

Actualmente, es el patrón que se sigue para el desarrollo de las aplicaciones Web, y a pesar, de que la interfaz gráfica del sistema propuesto no se encuentra orientado a páginas Web, se optó por usar este modelo para el desarrollo debido que el dispositivo móvil funciona como interfaz de usuario. La figura 3.8 muestra un esquema de la correlación entre los tres componentes del modelo.



Página 55

Figura 3.8 - Correlación entre el modelo, la vista y el controlador

3.3.1 Componente modelo: MySQL

Para la administración de los datos, el sistema de gestión de base de datos seleccionado fue MySQL, debido a su licencia libre, además del soporte que otorga para las bases de datos relacionales. Además, al contrario de Microsoft SQL Server, aporta la característica de transportabilidad, ya que es capaz de funcionar en cualquier sistema. Otro criterio importante para la selección de este gestor, es la conectividad que tiene con Java, la cual se consigue utilizando un simple conector que se descarga a través de la página web de Java. La figura 3.9 muestra el logotipo del gestor de base de datos seleccionado para el diseño del sistema propuesto, junto con una representación gráfica del componente modelo.

Figura 3.9 - El modelo del sistema propuesto



Página 56

3.3.2 Componente vista: Android

Para la selección del sistema operativo de dispositivos móviles a usar en el diseño del sistema propuesto, se encontró la estadística de los sistemas operativos más usados en el último año y se muestra en la figura 3.10. En esta figura claramente se observa que Android es el sistema operativo más utilizado actualmente.

Figura 3.10 - Estadística tomada de la página web http://gs.statcounter.com

Además, goza de una licencia GNU GLP, e inclusive, funciona en dispositivos móviles de diferentes marcas. Por todo esto, Android es el sistema operativo que se usa en el diseño del sistema propuesto y esto se muestra en la figura 3.11 como el componente de la vista, es decir, la interfaz del usuario.



Página 57

Figura 3.11 - S.O. seleccionado para la vista del proyecto: Android

3.3.3 Componente controlador: Servidor Apache Tomcat

La selección del servidor Tomcat fue debido a que se encontró una plataforma

huésped gratuita “Jelastic”.[XXIX] Además, es compatible con los servlets de Java,

los cuales utilizaremos para controlar los datos enviados por la interfaz de usuario,

así como para administrar nuestra base de datos. La figura 3.12 muestra a

Tomcat como el componente controlador elegido para el sistema propuesto.

Figura 3.12 - Servidor seleccionado para el componente controlador: Tomcat

3.4 Comunicación entre componentes: Wi-Fi Para la comunicación entre los componentes de la vista y los otros dos, se seleccionó al Wi-Fi, debido a la gran cantidad de redes Wi-Fi que existen actualmente, con lo que se le otorga flexibilidad al usuario para conectarse al sistema utilizando su dispositivo móvil. La figura 3.13 muestra el logotipo de este esquema de comunicación inalámbrica.



Página 58

Figura 3.13 - Logotipo del esquema de comunicación: Wi-Fi

Finalmente, en la figura 3.14 se muestra un esquema general de todas las tecnologías aplicadas al sistema propuesto, así como su correlación entre ellas como componentes del modelo vista controlador, utilizado para diseñar el sistema propuesto.

Figura 3.14 - Diagrama general del diseño para el sistema propuesto.



Página 59

4. Diseño y desarrollo del sistema propuesto.

Para explicar el diseño del sistema propuesto, se utiliza del siguiente ejemplo: Un alumno del IPN solicita que se haga una equivalencia de materias que cursó en otra universidad. Para que esto se lleve a cabo, se requiere de un formato, el cual se presenta en el anexo A.1. Para que la solicitud comience su procedimiento, requiere de la autorización del Jefe de Carrera a la cual pertenece el alumno, así como del Visto Bueno del Subdirector Académico. El Jefe de Carrera autorizará o no el formato presentado, de acuerdo a su criterio y reglamentos, pero una vez que decida aceptarlo, firmará el documento y colocará un sello de la jefatura para garantizar que el documento fue realmente firmado por él. Entonces, el formato se pasa a la subdirección académica para que el Subdirector Académico, quien revisará si se encuentra la firma del Jefe de Carrera. En caso de encontrarse, firmará para dar su Visto Bueno y colocará un sello de la subdirección académica para garantizar que realmente fue firmado por él. Una vez que ambas firmas se encuentren en el documento, se iniciará un siguiente procedimiento en la secretaría correspondiente, el cual ya está fuera del estudio del presente caso. Partiendo de esta premisa, se presenta el objetivo del sistema que compone al proyecto “K‟ajóolQR”, llamado así debido a la palabra -K‟ajóol- del vocabulario maya, que significa “identificar”, y al acrónimo QR, que atiende a los códigos QR utilizados para mostrar una firma digital en el proyecto.

4.1 Objetivo del sistema

El objetivo del sistema K‟ajóolQR es que sea capaz de producir y verificar firmas digitales en documentos oficiales. Para ello, el sistema es capaz de administrar una base de datos de usuarios, así como permitirle a cada usuario abrir una sesión en su dispositivo móvil. En esta sesión, el usuario podrá firmar un archivo seleccionado por él, ya sea para garantizar su autoría, otorgar su autorización con respecto a lo solicitado en el documento, o dar su visto bueno con respecto a una autorización concedida al mismo. Además de firmar archivos, el usuario también podrá verificar a quien pertenecen las firmas del documento, así como el caso de cada firma, que podrá ser alguno de los anteriormente expuestos.



Página 60

4.2 Casos de uso

En la primera sentencia del objetivo del sistema, se abstraen dos casos de uso: en las partes donde se menciona “administrar una base de datos de usuarios” y en “abrir una sesión en su dispositivo móvil”. Ahora, se generalizan ambos casos de uso para finalmente definirlos como:

Administrar usuarios

Manejar sesiones En la segunda sentencia del objetivo, se aísla la parte de “firmar un archivo seleccionado”, y recordando que el proyecto está orientado a documentos oficiales, se concreta a: firmar documentos Finalmente, en la última sentencia del objetivo, se separa la sección de “verificar a quien pertenecen las firmas del documento”, y nuevamente debido a que el sistema va dirigido a documentos oficiales, el caso de uso se especifica en: Verificar documentos El sistema se instalará en un servidor y todos los casos de uso, salvo “administrar usuarios” que no interactuará con el usuario, interactúan tanto con el servidor como con los usuarios. En la figura 4.1 se representa gráficamente el diagrama de casos de uso del proyecto, donde se muestra las interacciones entre los actores y cada caso de uso.

Figura 4.1 - Diagrama de casos de uso del Sistema

4.2.1 Administrar usuarios

En este caso de uso, el servidor administra una base de datos de los usuarios que utilizan la aplicación. Para ello, se manipulan dos entidades: el usuario y el dispositivo móvil.



Página 61

C) Entidades

La relación que existe entre estas entidades es “uno-a-muchos”, pues un usuario puede poseer uno o varios dispositivos móviles, mientras que se restringirá a que un dispositivo móvil sólo pueda pertenecer a un usuario. La figura 4.2 muestra el diagrama entidad-relación para este caso de uso.

Figura 4.2 - Diagrama entidad-relación entre el usuario y el dispositivo móvil

Cada una de estas entidades tiene propiedades que se verán manipuladas en este caso de uso.

1. Usuario

Los datos que se requiere conocer de los usuarios son:

Id usuario (INT / PK) – Es el número de identificación del usuario.

Nombre de usuario (VARCHAR) – Con el que se inicia sesión.

Nombre completo (VARCHAR) – Es el que aparecerá en las firmas.

Título (VARCHAR) – También aparecerá en las firmas.

Password (VARCHAR) – Se usa para iniciar sesión. Además este campo estará encriptado usando el algoritmo MD5.

E-mail (VARCHAR) – Se usa para recuperar contraseñas.

Llave privada (VARCHAR) – Se usa para firmar documentos.

Llave pública (VARCHAR) – Se usa para validar firmas.

Activo (INT) – Indica si el usuario está dado de alta (1) o de baja (0). La tabla 4.1 muestra el diagrama entidad del usuario y sus atributos.



Página 62

Tabla 4.1 - Entidad usuario y sus atributos

En el anexo B.2 se encuentra el código SQL para crear la tabla de esta entidad.

2. Dispositivo Móvil

Los atributos de esta entidad son:

Id dispositivo (INT / PK) – Es el número de identificación del dispositivo.

Id usuario (INT / FK) – Es el número de identificación del usuario al que pertenece.

MAC (VARCHAR) – El número MAC del dispositivo.

Activo (INT) – Indica si el usuario está dado de alta (1) o de baja (0). La tabla 4.2 presenta gráficamente a la entidad junto a sus atributos.

Tabla 4.2 - Entidad dispositivo y sus atributos

D) Operaciones

La operación que es posible a realizar es insertar; ésta es aplicable a ambas entidades.

Insertar

Este proceso tiene como entrada los datos tanto del usuario, como del dispositivo desde donde se quiere hacer el registro de la cuenta. Estos datos son



Página 63

enviados al servidor, el cual realizará algunas verificaciones para determinar el tipo de caso, el cual puede ser:

A. Tanto el usuario como el dispositivo, no han sido guardados previamente. B. El usuario ya fue registrado anteriormente y el dispositivo puede o no haber

sido registrado. C. El usuario nunca se ha dado de alta, pero el dispositivo ya fue dado de alta

a nombre de otra persona. En el caso A el servidor guarda ambas entidades y envía un mensaje de confirmación al usuario. En el caso B el servidor no guarda ninguna de las entidades y envía un mensaje para que el usuario utilice otro nombre de usuario. En el caso C el servidor únicamente guarda el usuario pero el dispositivo no. De la figura 4.3, donde los datos de entrada del proceso son capturados en la interfaz gráfica de usuario, o dispositivo móvil. Una vez que el usuario ingresa los datos, éstos son enviados a internet, donde se encuentra el servidor. Cuando el servidor obtenga los datos, los procesará, generando una respuesta que nuevamente enviará a través de internet. El dispositivo móvil del usuario recibirá la respuesta y la desplegará en la pantalla para conocimiento del usuario.

Figura 4.3 - Esquema del proceso de insertar usuarios



Página 64

En la figura 4.4 se muestra una captura de pantalla del formulario de registro de usuario, mediante la cual el usuario ingresará sus datos. En este formulario se encuentran los campos que deben ser llenados por el usuario, los cuales son:

Nombre de usuario, el cual servirá para identificarlo en su sesión. Este campo acepta letras, números y caracteres especiales.

Nombre completo, el cual será el que se muestre en las firmas. Únicamente acepta letras y espacios.

Título profesional, el cual también se incluirá en las firmas. Permite el uso de letras, espacios y puntos.

Password, que será utilizado por el usuario para iniciar su sesión. Permite todo tipo de caracteres.

Confirmación del password, el cual sirve para saber si el usuario está seguro del primer password y deberá ser exactamente igual a lo ingresado en la caja de texto anterior.

E-mail, el cual servirá para que el usuario establezca las firmas requeridas en un documento. Acepta letras, números y el carácter especial arroba.

Figura 4.4 - Formulario de registro de usuarios



Página 65

En el anexo C.4 se encuentra el código necesario para crear esta interfaz de usuario. La clase encargada de procesar y enviar estos datos se encuentra en el anexo C.5. El algoritmo para la inserción de ambas entidades se representa gráficamente en la figura 4.5.

Figura 4.5 - Diagrama de flujo para el algoritmo de insertar usuarios y dispositivos



Página 66

Para el proceso de creación de las llaves pública y privada, el código se encuentra en el anexo D13. Cabe mencionar que las llaves pública y privada se encriptan utilizando el algoritmo Estándar de Encriptación de Datos, debido a que resultaría inseguro que fueran guardadas sin ningún proceso previo. El proceso de encriptación para ambas llaves se muestra en las figuras 4.6 y 4.7 respectivamente.

Figura 4.6 - Encriptación de llave pública

Figura 4.7 - Encriptación de llave privada

Para el algoritmo de encriptación se utilizó el código mostrado en el anexo D6. El mensaje de salida, será mostrado en el dispositivo móvil para conocimiento del usuario, y será dependiendo de uno de los tres casos, expuestos anteriormente. El mensaje de respuesta para el caso en que tanto el usuario como el dispositivo no han sido registrados, es decir el caso A, se muestra en la figura 4.8. Además del mensaje, la interfaz muestra un link con el texto “¡Regresar! Entra aquí”, el cual nos regresa al primer formulario, que es el de inicio de sesión.

Figura 4.8 - Salida para el caso A



Página 67

El mensaje que el servidor muestra en el caso de que el nombre de usuario que fue seleccionado ya fue ocupado por otra persona, es decir el caso B, se muestra en la figura 4.9. El usuario deberá colocar otro nombre diferente, en caso contrario, el programa no saldrá de ese formulario.

Figura 4.9 - Salida para el caso B

Finalmente, el mensaje que otorga el servidor para el caso en que el usuario no ha sido ocupado, pero el dispositivo ya está registrado a nombre de otra persona, es decir para el caso C, se muestra en la figura 4.10. De la misma forma que en el primer caso, el mensaje contiene un link con el texto “¡Regresar! Entra aquí”, el cual lleva al formulario de inicio de sesión.

Figura 4.10 - Salida para el caso C

4.2.2 Manejar Sesiones

Para este caso de uso, se explicará brevemente lo que es una sesión. Una sesión es la duración de la conexión entre el usuario y el servidor, generalmente involucrando el intercambio de múltiples paquetes de datos entre la computadora del usuario y el servidor En el caso del sistema propuesto, esta sesión tiene una duración de 10 minutos, en los cuales el usuario podrá comunicarse con el servidor ya sea para firmar o para validar firmas. Por razones de seguridad, la decisión permanece abierta durante 10 minutos, dado que se considera un tiempo suficiente, para que el usuario realice las acciones que requiere y si se olvida de cerrar su sesión, este límite de tiempo impedirá que otras personas puedan utilizar su dispositivo para firmar en su nombre.



Página 68

Las entidades afectadas en este caso, son los dispositivos, a los cuales se le agregarán atributos los cuales servirán para la manipulación de sesiones. Las operaciones permitidas en este caso son la de iniciar y la de cerrar sesión.

A) Entidades

Las dos entidades que se usan en el caso de administrar usuarios interactúan

entre sí. Así, en este caso de uso, únicamente la entidad Dispositivo se ve

afectada directamente, dado que el Usuario únicamente sirve para dar una

referencia, pero ningún campo de esta entidad se emplea.

1. Dispositivo

Los atributos que se le añaden a esta entidad son:

sesión (INT) – Es el número de indica si hay alguna sesión abierta(1) en ese dispositivo o no(0).

Id usuario sesión (INT / FK) – Es el número de identificación del usuario que tiene abierta su sesión en ese dispositivo.

Hora sesión (VARCHAR) – Es la hora en la cual se abrió la sesión. La tabla 4.3 presenta la entidad Dispositivo junto a todos sus atributos.

Tabla 4.3 - Entidad dispositivo junto con sus atributos

B) Operaciones

Las operaciones posibles en este caso de uso son: iniciar y cerrar la sesión.

1. Iniciar sesión

Para este proceso, el dispositivo manda su MAC, con el objetivo de que el servidor busque si hay alguna sesión abierta en ese dispositivo. De ser así, el servidor hace una comparación entre la hora en la que se abrió la sesión en ese dispositivo y la hora en que el usuario accede al programa; si el tiempo es menor o igual a 10



Página 69

minutos, permite el acceso al usuario, mientras que si el tiempo es mayor a los 10 minutos, le niega el acceso y le pide al usuario identificarse nuevamente. La figura 4.11, muestra el proceso general del inicio de sesión.

Figura 4.11 - Diagrama de proceso de inicio de sesión

Esta figura también muestra los datos de entrada que se envían desde el dispositivo móvil. Una vez que el usuario ingresa los datos, éstos son enviados al internet, donde se encuentra el servidor. Cuando el servidor obtenga los datos, los procesará, generando una respuesta que nuevamente enviará a través del internet. El dispositivo móvil del usuario recibirá la respuesta y la desplegará en la pantalla para conocimiento del usuario. Este proceso comienza con la interfaz gráfica del usuario, con el formulario para el inicio de sesión, el cual se muestra en la figura 4.12. Este formulario consta de dos cajas de texto en las cuales el usuario ingresará su nombre de usuario y su password; ambas cajas de texto permiten el uso de todo tipo de caracteres. Una vez que el usuario haya ingresado sus datos, deberá dar „click‟ en el botón “Login” para enviar sus datos al servidor.



Página 70

Figura 4.12 - Formulario para el inicio de sesión

En el anexo C6 se encuentra el código para crear la interfaz gráfica de la figura 4.12, mientras que en el anexo C7 está el código que controla el envío de estos datos al servidor. Así, cuando el servidor recibe los datos, comprueba si el usuario existe. En caso de ser así, verifica que el dispositivo sea de su pertenencia, y si no lo es, le solicita que el dueño del dispositivo introduzca su contraseña. Posteriormente, muestra al usuario un menú, en el cual puede seleccionar entre firmar un documento, validar una firma, o cerrar la sesión. En la figura 4.13 se muestra el formulario necesario para el caso en que el dispositivo no sea de la pertenencia del usuario que inició la sesión. Como se observa, presenta una caja de texto, La cual, permite cualquier tipo de caracteres y donde el dueño del dispositivo ingresa su contraseña, además de un botón que se oprimirá para que el usuario que inicie continúe. Además, incluye un enlace en el texto “¡No gracias! Salir”, con el cual es posible salir de la aplicación.

Figura 4.13 - Formulario para préstamo del dispositivo móvil.



Página 71

En el anexo C8 se encuentra el código para crear la interfaz gráfica de la figura 4.13, en tanto que, que en el anexo C9 está el código que controla el envío de estos datos al servidor. El algoritmo que inicializa la sesión de los usuarios en el servidor, se muestra en la figura 4.14. Cuyo código se encuentra en el anexo C10, mientras que el código que se utiliza para el caso en que el dispositivo no es de la propiedad del usuario que desea iniciar la sesión, se encuentra en el anexo C11. Cuando el servidor permite que el usuario continúe, la interfaz gráfica muestra un menú de opciones que el usuario puede seleccionar. Esta interfaz se encuentra en la figura 4.15, y se conforma por dos botones, los cuales sirven para ingresar a los siguientes casos de uso: firmar un documento y validar una firma. Además, contiene un enlace para cerrar la sesión y la aplicación, el cual contiene el texto “Cerrar sesión”.



Página 72

Figura 4.14 - Algoritmo del servidor para el inicio de las sesiones.



Página 73

Figura 4.15 - Menú de opciones para el usuario.

En el anexo C10 se encuentra el código para la creación de la interfaz gráfica mostrada en la figura 4.15, mientras que el código que controla la lógica de la selección del usuario se encuentra en el anexo C11.

2. Cierre de Sesión

Cuando el usuario termine de utilizar el programa, puede cerrar la sesión, dándole „click‟ a un enlace. Con esto, el dispositivo móvil enviará su MAC al servidor, para que este marque en la base de datos que la sesión se terminó, y le envíe un mensaje de confirmación al usuario. Este proceso es el mostrado en la figura 4.16.

Figura 4.16 - Proceso de cierre de sesión



Página 74

El algoritmo que utiliza el servidor para el cierre de sesión se muestra en la figura 4.17.

Figura 4.17 - Diagrama de flujo para el cierre de sesión

En el anexo D.11 se encuentra el programa, seguido por el servidor para el proceso de cierre de sesión.

4.2.3 Firmar Documentos

En este caso de uso, la variable de entrada será un documento seleccionado por el usuario, en tanto que la respuesta del proceso será una imagen en código QR que representa una firma. El esquema general de este proceso es el mostrado en la figura 4.18.



Página 75

Figura 4.18 - Diagrama del proceso de firma

Entidad

Las dos entidades que se usan en el caso de uso de firmar documentos son

firmas y usuarios. Sin embargo, únicamente la entidad Firmas es la que no se ha

explicado cómo se conforma.

Los atributos de esta entidad son:

Id dispositivo (INT / PK) – Es el número de identificación del dispositivo.

Id usuario (INT / FK) – Es el número de identificación del usuario al que pertenece.

MAC (VARCHAR) – El número MAC del dispositivo.

Activo (INT) – Indica si el usuario está dado de alta (1) o de baja (0). La tabla 4.2 presenta gráficamente a la entidad junto a sus atributos.

Tabla 4.4 - Entidad firma y sus atributos

Una vez que el usuario selecciona el botón “firmar documento” del menú de opciones, se le presentará una lista del directorio que contiene su memoria externa, en la cual el usuario seleccionará el documento a ser firmado. La interfaz gráfica de esta parte se encuentra en la figura 4.19.



Página 76

Figura 4.19 - Selección del documento a firmar

El código para crear la interfaz de usuario para la selección del documento a firmar se encuentra en el anexo C12, mientras que el código para el control de esta selección se encuentra en el anexo C13. El algoritmo seguido tanto por el dispositivo móvil como por el servidor para la creación del código QR que tendrá la firma encriptada es el mostrado por la figura 4.20.



Página 77

Figura 4.20 - Algoritmo de la encriptación de la firma.

En el anexo D.12 se encuentra el código que se encuentra en el servidor, encargado de formar la firma digital, encriptarla y enviarla El diagrama que muestra la conformación de la firma que se mostrará en el código QR se representa en la figura 4.21 en la cual se muestran las claves que resultarán de la búsqueda de cada valor en la base de datos. Cada valor será guardado en la base de datos encriptado por razones de seguridad. Cuando se requiera saber de quienes son las firmas, únicamente bastará con hacer el proceso invertido encontrando los ID de cada firmante y de esa forma buscándolos en la base de datos.



Página 78

Figura 4.21 - Conformación de la firma que se mostrará en el código QR

Para la creación de la firma, en la figura 4.22 se muestra el proceso que se lleva a cabo para cada usuario utilizando el algoritmo DSA. El mensaje varía para cada usuario que firma el documento, siendo el hash para el primero que firma, y siendo la firma resultante de la persona que firmó para los dos siguientes. Del mismo modo, para validar la firma deberá de hacerse del mismo modo pero en sentido invertido.

Figura 4.22 - Proceso para la firma DSA

Una vez creado el código QR, éste se muestra en el dispositivo móvil, de la forma representada por la figura 4.23, la cual contiene el código QR y el texto que



Página 79

se le mostrará a la persona que lo lea con cualquier otra aplicación de códigos QR.

Figura 4.23 - Código QR generado con la firma encriptada.

.

4.2.4 Validar Firmas

Para este caso de uso del sistema, la variable de entrada es una imagen en código QR que represente una firma, la cual será leída con un dispositivo móvil. La respuesta del proceso es un mensaje que dice si la firma es válida y a quien o quienes les pertenece esa firma. La figura 4.22 muestra el diagrama de proceso general de la validación.

Figura 4.24 - Diagrama del proceso de validación



Página 80

Una vez que el usuario selecciona la opción de validar firma, se mostrará una aplicación que utiliza la cámara del dispositivo móvil, con lo que el usuario deberá de colocar el celular de forma que lea el código QR. Para el proceso de validación se utiliza el proceso que se muestra en la figura 4.23.

Figura 4.25 - Diagrama que muestra el proceso de validación de una firma con DSA.

Cuando el lector haya leído satisfactoriamente el código QR, en la pantalla se mostrará el nombre del archivo y por quien ha sido firmado. La figura 4.24 muestra un ejemplo de un documento cuando el documento ha sido firmado por una sola persona. Además muestra un link “¡Regresar! Entra aquí” el cual lleva al menú de opciones.

Figura 4.26 - Mensaje desencriptado mostrando quien firmó el documento



Página 81

5. Implementación del proyecto Para la correcta implementación del proyecto se deben tomar en cuenta dos cosas: La normativa ISO que corresponde a este proyecto, es la ISO/IEC 9796-2:2010 la cual especifica tres esquemas de firma digital, entregando mensajes, dos de las cuales son determinísticas y una es aleatoria. Además, especifica también el método de producción de llaves para estos tres esquemas, pero no incluye las técnicas para la administración de llaves y la generación aleatoria de números. Al ser el presente proyecto, un prototipo, aún no se encuentra dentro de esta normatividad, debido a que no se conocen las técnicas de generación de llaves que se mencionan en el documento, pero adquiriéndolo, podrían implementarse. La segunda cuestión a mencionar para la implementación del proyecto, es que al ser un mecanismo de encriptación, el proyecto no debe salir tal cual al mercado, debido a que se revelan cuales son los varios mecanismos de encriptación y protecciones contra intrusos. Así, para poderse implementar, debe de cambiarse todos los algoritmos de encriptación y no revelarse al público los nuevos mecanismos de protección.



Página 82

6. Conclusiones

Se desarrolló un software que firma electrónicamente documentos oficiales.

Este sistema podría utilizaren la agilización de los diversos trámites que se

realizan en una institución, en donde se requiera firmar documentos oficiales, en

distintos niveles de jerarquía, una autorización, un visto bueno, por ejemplo..

Se desarrollaron algoritmos para codificar y decodificar una firma digital, además

se implementó una base de datos para el funcionamiento del sistema. Se creó un

software que efectúa los procesos del servidor, para la encriptación y la

administración de la base de datos., así como una aplicación para el sistema

operativo Android, que genera códigos QR a partir de un proceso del servidor y es

capaz de leerlos. También se logró la comunicación de red inalámbrica entre los

dispositivos móviles y el servidor.

Además es posible ampliar el sistema a diversos casos de uso, donde se

requiera identificarse ante alguna empresa, para un sistema en el que el usuario

únicamente requiera de su dispositivo móvil para pagar un producto y en sistemas

del mismo rubro, por ejemplo.

Finalmente, comparando el sistema propuesto con el desarrollado en la

universidad de Sao Paulo, se logró una mejora en el tiempo de 45 segundos de la

codificación y decodificación de las firmas digitales, ya que con el sistema

propuesto se consigue realizar en un aproximado de 5 segundos, dependiendo de

la velocidad de conexión a internet.



Página 83

Anexos



Página 84

A. Anexo – Formatos de documentos oficiales



Página 85

A.1 Formato de Equivalencia de Estudios del IPN

El presente es un formato que requiere dos firmas: una de autorización y otra de

visto bueno.



Página 86

B. Anexo – Códigos de la programación de la Base de Datos



Página 87

B.1 – Código para crear la base de datos del sistema

CREATE TABLE IF NOT EXISTS `kajoolqrweb`

B.2 – Código para crear la tabla de usuarios

En esta sección se encuentra el código para crear la tabla de la entidad Usuario en el lenguaje SQL. -- -- Estructura de tabla para la tabla ùsuarios` -- CREATE TABLE IF NOT EXISTS ùsuarios` ( ìd_usuario` int(11) NOT NULL AUTO_INCREMENT, `nombre_usuario` varchar(30) NOT NULL, `nombre_completo` varchar(200) NOT NULL, `titulo` varchar(200) NOT NULL, `pass` varchar(200) NOT NULL, è_mail` varchar(200) NOT NULL, `llave_privada` blob NOT NULL, `llave_publica` blob NOT NULL, èsta_activo` int(11) NOT NULL, PRIMARY KEY (ìd_usuario`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=10 ;



Página 88

C. Anexo – Códigos de la programación en Android



Página 89

C.1 Código del texto que aparece en la interfaz gráfica del usuario.

Presenta el archivo “strings.xml”, el cual contiene todo el texto que se le mostrará al usuario en la aplicación. Siempre que en algún archivo XML se encuentre un pedazo de código “@string/<alguna cadena>”, está haciendo referencia a este archivo, y buscará la cadena a la cual está referenciada. <resources> <string name="app_name">KajoolQRApp</string> <string name="hello_world">Hello world!</string> <string name="menu_settings">Settings</string> <string name="titulo_aplicacion">KajóolQR</string> <string name="logo_descripcion">Logo de la aplicación</string> <string name="logo_android">Logo de Android</string> <string name="login">Login</string> <string name="registrar">Registrar nueva cuenta</string> <string name="usuario">Usuario</string> <string name="nombre">Nombre Completo</string> <string name="titulo">Titulo</string> <string name="password">Password</string> <string name="confirma_password">Confirma el password</string> <string name="email">E-mail</string> <string name="r2Web">https://r2rock.jelastic.servint.net/kajool/</string> <string name="nuevoEnKajool">¿Nuevo en KajoolQR? Registrate aqui</string> <string name="ya_tengo_cuenta">¡Ya tengo cuenta! Entra aqui</string> <string name="regresar">¡Regresar! Entra aqui</string> <string name="instrucciones">Selecciona una acción</string> <string name="firmar">Firmar un Archivo</string> <string name="leer">Escanear un QR</string> <string name="title_activity_login">Login</string> <string name="title_activity_registrar">Registrar</string> <string name="title_activity_mensaje">Mensaje</string> <string name="title_activity_menu">Menu</string> <string name="title_activity_filechooser">Selecciona un archivo</string> <string name="title_activity_enviar_archivo">EnviarArchivo</string> </resources>



Página 90

C.2 Código del encabezado que aparece en la interfaz gráfica del usuario.

Muestra el archivo “encabezado.xml”; en él, se ubica una gradiente de colores guinda. <?xml version="1.0" encoding="utf-8"?> <shape xmlns:android="http://schemas.android.com/apk/res/android"> <gradient android:startColor="#6b1842" android:centerColor="#a24e78" android:endColor="#ca75a0" android:angle="0"/> <corners android:radius="5dp" /> </shape>

C.3 Código del pie de página que aparece en la interfaz gráfica del usuario.

Muestra el archivo “pie_de_pagina.xml”, en el que se indica la repetición de una imagen que contiene ondas que mejora la presentación de la interfaz gráfica. <?xml version="1.0" encoding="utf-8"?> <bitmap xmlns:android="http://schemas.android.com/apk/res/android" android:src="@drawable/bg_repeat" android:tileMode="repeat" />

Página 91

C.4 Código de la interfaz gráfica de usuario para el formulario de registro de usuarios.

Este es el archivo “registrar.xml”, el cual contiene los bloques necesarios para formar el formulario de registro de usuarios, presentado en la imagen 4.6, del capítulo 4. <?xml version="1.0" encoding="utf-8"?> <ScrollView xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:fillViewport="true"> <RelativeLayout android:layout_width="fill_parent" android:layout_height="wrap_content" android:background="#fff">  <LinearLayout android:id="@+id/header" android:layout_width="fill_parent" android:layout_height="wrap_content" android:background="@layout/encabezado" android:paddingTop="5dip" android:paddingBottom="5dip"> <ImageView android:src="@drawable/logo_letras" android:contentDescription="@string/logo_descripcion" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginLeft="10dip"/> </LinearLayout>  <LinearLayout android:id="@+id/footer" android:layout_width="fill_parent" android:layout_height="90dip" android:background="@layout/pie_de_pagina" android:layout_alignParentBottom="true"> </LinearLayout>  <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="wrap_content" android:padding="10dip" android:layout_below="@id/header">

Página 92

<TextView android:id="@+id/reg_lbl_usuario" android:layout_width="fill_parent" android:layout_height="wrap_content" android:textColor="#6e1942" android:text="@string/usuario"/> <EditText android:id="@+id/reg_usuario" android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_marginTop="5dip" android:singleLine="true" android:inputType="textPersonName" android:layout_marginBottom="5dip"/>  <TextView android:id="@+id/reg_lbl_nombre" android:layout_width="fill_parent" android:layout_height="wrap_content" android:textColor="#6e1942" android:text="@string/nombre"/> <EditText android:id="@+id/reg_nombre" android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_marginTop="5dip" android:singleLine="true" android:inputType="textPersonName" android:layout_marginBottom="5dip"/>  <TextView android:id="@+id/reg_lbl_titulo" android:layout_width="fill_parent" android:layout_height="wrap_content" android:textColor="#6e1942" android:text="@string/titulo"/> <EditText android:id="@+id/reg_titulo" android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_marginTop="5dip" android:singleLine="true" android:inputType="text" android:layout_marginBottom="5dip"/>  <TextView android:layout_width="fill_parent" android:layout_height="wrap_content" android:textColor="#6e1942" android:text="@string/password"/>

Página 93

<EditText android:id="@+id/reg_password" android:layout_width="fill_parent" android:layout_height="wrap_content" android:inputType="textPassword" android:singleLine="true" android:layout_marginTop="5dip"/>  <TextView android:layout_width="fill_parent" android:layout_height="wrap_content" android:textColor="#6e1942" android:text="@string/confirma_password"/> <EditText android:id="@+id/reg_conf_password" android:layout_width="fill_parent" android:layout_height="wrap_content" android:inputType="textPassword" android:singleLine="true" android:layout_marginTop="5dip"/>  <TextView android:id="@+id/reg_lbl_email" android:layout_width="fill_parent" android:layout_height="wrap_content" android:textColor="#6e1942" android:text="@string/email"/> <EditText android:id="@+id/reg_email" android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_marginTop="5dip" android:singleLine="true" android:inputType="textEmailAddress" android:layout_marginBottom="5dip"/>  <Button android:id="@+id/btn_registrar" android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_marginTop="10dip" android:text="@string/registrar" android:onClick="registrar"/>  <TextView android:id="@+id/link_a_login" android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_marginTop="10dip"



Página 94

android:layout_marginBottom="80dip" android:text="@string/ya_tengo_cuenta" android:gravity="center" android:textSize="20dip" android:textColor="#6e1942" android:onClick="irActividadLogin" android:clickable="true"/> </LinearLayout> </RelativeLayout> </ScrollView>



Página 95

C.5 Código del control para el envío del formulario de registro de usuarios.

Este es el archivo “Registrar.java”, el cual contiene el control para enviar el formulario de registro de usuarios, presentado en la imagen 4.6, del capítulo 4. package com.r2.mx.kajoolqr.app; import java.util.ArrayList; import java.util.List; import com.r2.mx.kajoolqr.app.ssl.Parametro; import com.r2.mx.kajoolqr.app.ssl.SSL; import android.net.wifi.WifiManager; import android.os.Bundle; import android.app.Activity; import android.content.Context; import android.content.Intent; import android.view.KeyEvent; import android.view.View; import android.widget.EditText; import android.widget.Toast; public class Registrar extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.registrar); } /********************************************************** * * --- Método registrar --- * Este método funciona cuando el usuario da click en el * botón Registrar * * Recibe como parámetro un objeto de tipo View, de * acuerdo con la clase OnClickListener de android. * * El algoritmo de control para enviar los datos de * usuario es el siguiente: * -Comprueba que ambos passwords sean iguales, en * caso contrario, envía un mensaje para que el * usuario reingrese ambos. * -Reune los datos para el POST en una lista de * objetos Parametro. * -Conecta mediante sockets al servidor y envía * los parámetros. * -Recibe el mensaje del servidor. * -Crea un paquete Bundle que enviará a la * siguiente actividad. * -Introduce el mensaje recibido y la presente



Página 96

* actividad al paquete. * -Abre un Intent de la actividad Mensaje y le * envia el paquete. * -Termina el Intent de la presente actividad. * ***********************************************************/ public void registrar(View view){ if(comprobarPassword()){ List<Parametro> parametros = reunirDatos(); String url = "https://r2rock.jelastic.servint.net/kajool/Registrar"; SSL socket = conectar(parametros, url); // String mensaje = recibeMensaje(socket); Bundle bundle = new Bundle(); bundle.putString("mensaje", mensaje); bundle.putString("actividad", "Login"); Intent i = new Intent(getApplicationContext(), Mensaje.class); i.putExtras(bundle); startActivity(i); finish(); }else{ String mensaje = "Verifica que el password y su comprobación sean iguales"; Toast.makeText(this, mensaje, Toast.LENGTH_SHORT).show(); } } public void irActividadLogin(View view){ Intent i = new Intent(this, Login.class); startActivity(i); finish(); } private boolean comprobarPassword(){ boolean iguales = false; String password = ((EditText)findViewById(R.id.reg_password)).getText().toString(); String confirmaPassword = ((EditText)findViewById(R.id.reg_conf_password)).getText().toString(); if(password.equals(confirmaPassword)) iguales = true; return iguales; } private List<Parametro> reunirDatos(){ String mac = ((WifiManager)this.getSystemService(Context.WIFI_SERVICE)).getConnectionInfo().getMacAddress(); String usuario = ((EditText)findViewById(R.id.reg_usuario)).getText().toString(); String nombre = ((EditText)findViewById(R.id.reg_nombre)).getText().toString();



Página 97

String titulo = ((EditText)findViewById(R.id.reg_titulo)).getText().toString(); String password = ((EditText)findViewById(R.id.reg_password)).getText().toString(); String confirmaPassword = ((EditText)findViewById(R.id.reg_conf_password)).getText().toString(); String email = ((EditText)findViewById(R.id.reg_email)).getText().toString(); List<Parametro> parametros = new ArrayList<Parametro>(); parametros.add(new Parametro("mac", mac)); parametros.add(new Parametro("usuario", usuario)); parametros.add(new Parametro("nombre", nombre)); parametros.add(new Parametro("titulo", titulo)); parametros.add(new Parametro("password", password)); parametros.add(new Parametro("confirmaPassword", confirmaPassword)); parametros.add(new Parametro("email", email)); return parametros; } private SSL conectar(List<Parametro> parametros, String url){ SSL socket = new SSL(); socket.setParametros(parametros); socket.conectarConURL(url); return socket; } private String recibeMensaje(SSL socket){ String mensaje = null; if(socket.getError()==null) mensaje = socket.getMsjEntrada(); else mensaje = socket.getError(); return mensaje; } @Override public boolean onKeyDown(int keyCode, KeyEvent event){ if ((keyCode == KeyEvent.KEYCODE_BACK)){ Intent i = new Intent(this, Login.class); startActivity(i); finish(); } return super.onKeyDown(keyCode, event); } }



Página 98

C.6 Código para crear la interfaz gráfica del formulario de inicio de sesión

<?xml version="1.0" encoding="utf-8"?> <ScrollView xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:fillViewport="true"> <RelativeLayout android:layout_width="fill_parent" android:layout_height="wrap_content" android:background="#ffffff"> <LinearLayout android:id="@+id/header" android:layout_width="fill_parent" android:layout_height="wrap_content" android:background="@layout/encabezado" android:paddingTop="5dip" android:paddingBottom="5dip"> <ImageView android:src="@drawable/logo_letras" android:contentDescription="@string/logo_descripcion" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginLeft="10dip"/> </LinearLayout> <LinearLayout android:id="@+id/footer" android:layout_width="fill_parent" android:layout_height="90dip" android:background="@layout/pie_de_pagina" android:layout_alignParentBottom="true"> </LinearLayout> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="wrap_content" android:padding="10dip" android:layout_below="@id/header"> <TextView android:id="@+id/lbl_usuario" android:layout_width="fill_parent" android:layout_height="wrap_content" android:textColor="#6e1942" android:textSize="15dip" android:text="@string/usuario"/> <EditText android:id="@+id/usuario" android:layout_width="fill_parent"



Página 99

android:layout_height="wrap_content" android:layout_marginBottom="5dip" android:inputType="textPersonName" android:singleLine="true"/> <TextView android:layout_width="fill_parent" android:layout_height="wrap_content" android:textColor="#6e1942" android:textSize="15dip" android:layout_marginBottom="5dip" android:text="@string/password"/> <EditText android:id="@+id/password" android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_marginTop="5dip" android:singleLine="true" android:inputType="textPassword"/> <Button android:id="@+id/btn_login" android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_marginTop="10dip" android:text="@string/login" android:onClick="login"/> <TextView android:id="@+id/link_a_registrar" android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_marginTop="20dip" android:layout_marginBottom="100dip" android:text="@string/nuevoEnKajool" android:gravity="center" android:textSize="20dip" android:textColor="#6e1942" android:onClick="irActRegistro" android:clickable="true"/> </LinearLayout> </RelativeLayout> </ScrollView>



Página 100

C.7 Código para el control del envío de datos para el inicio de sesión.

package com.r2.mx.kajoolqr.app; import java.util.ArrayList; import java.util.List; import com.r2.mx.kajoolqr.app.R; import com.r2.mx.kajoolqr.app.ssl.Parametro; import com.r2.mx.kajoolqr.app.ssl.SSL; import com.r2.mx.kajoolqr.app.ssl.AsistenteSocket; import android.net.wifi.WifiManager; import android.os.Bundle; import android.app.Activity; import android.content.Context; import android.content.Intent; import android.view.KeyEvent; import android.view.View; import android.widget.EditText; import android.widget.Toast; public class Login extends Activity { private String mac; private String usuario; private static final String CORRECTA_IDENTIFICACION = "A"; private static final String DISPOSITIVO_PRESTADO = "B"; private static final String USUARIO_PWD_INCORRECTOS = "C"; private static final String DISPOSITIVO_NO_REGISTRADO = "D"; private static final String DISPOSITIVO_GUARDADO = "1"; private static final String DISPOSITIVO_NO_GUARDADO = "0"; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.login); } /********************************************************** * * --- Método login --- * Este método funciona cuando el usuario da click en el * botón Login * * Recibe como parámetro un objeto de tipo View, de



Página 101

* acuerdo con la clase OnClickListener de android. * * El algoritmo de control para enviar los datos de * usuario es el siguiente: * -Reune los datos para el POST en una lista de * objetos Parametro. * -Conecta mediante sockets al servidor y envía * los parámetros. * -Recibe el mensaje del servidor. * -Crea un paquete Bundle que enviará a la * siguiente actividad. * -Introduce el mensaje recibido * -Abre un Intent de la actividad Menu y le * envia el paquete. * -Termina el Intent de la presente actividad. * **********************************************************/ public void login(View view) { List<Parametro> parametros = reunirDatos(); String url = "https://r2rock.jelastic.servint.net/kajool/Login"; SSL socket = AsistenteSocket.conectar(parametros, url); String entrada = AsistenteSocket.recibeMensaje(socket); if(entrada.equals(USUARIO_PWD_INCORRECTOS)){ String mensaje = "Usuario y/o password incorrecto(s)"; Toast.makeText(this, mensaje, Toast.LENGTH_SHORT).show(); }else{ Bundle bundle = new Bundle(); Intent i = null; String[] datos = entrada.split(";"); if(datos[0].equals(CORRECTA_IDENTIFICACION)){ bundle.putString("idUsuario", datos[1]); bundle.putString("usuario", datos[2]); i = new Intent(this, Menu.class); } if(datos[0].equals(DISPOSITIVO_PRESTADO)){ bundle.putString("usuario", usuario); bundle.putString("mac", mac); i = new Intent(this, PermitirDispositivo.class); } if(datos[0].equals(DISPOSITIVO_NO_REGISTRADO)){ String[] datosDisp = registrarDispositivo(datos); String mensaje = ""; if(datosDisp[0].equals(DISPOSITIVO_GUARDADO)) mensaje = "Dispositivo registrado"; if(datosDisp[0].equals(DISPOSITIVO_NO_GUARDADO)) mensaje = "Dispositivo NO registrado";



Página 102

Toast.makeText(this, mensaje, Toast.LENGTH_SHORT).show(); bundle.putString("idUsuario", datosDisp[1]); bundle.putString("usuario", datosDisp[2]); i = new Intent(this, Menu.class); } i.putExtras(bundle); startActivity(i); finish(); } } public void irActRegistro(View view){ Intent i = new Intent(this, Registrar.class); startActivity(i); finish(); } private String[] registrarDispositivo(String[] datos){ List<Parametro> parametros = new ArrayList<Parametro>(); parametros.add(new Parametro("idUsuario", datos[1])); parametros.add(new Parametro("nombreUsuario", datos[2])); parametros.add(new Parametro("mac", datos[3])); parametros.add(new Parametro("opcion", "dispositivo")); String url = "https://r2rock.jelastic.servint.net/kajool/Registrar"; SSL socket = AsistenteSocket.conectar(parametros, url); String entradaDisp = AsistenteSocket.recibeMensaje(socket); String[] datosDisp = entradaDisp.split(";"); return datosDisp; } private List<Parametro> reunirDatos(){ mac = ((WifiManager)this.getSystemService(Context.WIFI_SERVICE)).getConnectionInfo().getMacAddress(); usuario = ((EditText)findViewById(R.id.usuario)).getText().toString(); String password = ((EditText)findViewById(R.id.password)).getText().toString(); List<Parametro> parametros = new ArrayList<Parametro>(); parametros.add(new Parametro("usuario", usuario)); parametros.add(new Parametro("mac", mac)); parametros.add(new Parametro("password", password)); return parametros; } @Override public boolean onKeyDown(int keyCode, KeyEvent event){ if (keyCode == KeyEvent.KEYCODE_BACK){



Página 103

finish(); } if(keyCode == KeyEvent.KEYCODE_HOME) finish(); return super.onKeyDown(keyCode, event); } }



Página 104

C.8 Código para el diseño de la interfaz para el formulario de permiso de uso del

dispositivo..

<?xml version="1.0" encoding="utf-8"?> <ScrollView xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:fillViewport="true"> <RelativeLayout android:layout_width="fill_parent" android:layout_height="wrap_content" android:background="#ffffff"> <LinearLayout android:id="@+id/header" android:layout_width="fill_parent" android:layout_height="wrap_content" android:background="@layout/encabezado" android:paddingTop="5dip" android:paddingBottom="5dip"> <ImageView android:src="@drawable/logo_letras" android:contentDescription="@string/logo_descripcion" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginLeft="10dip"/> </LinearLayout> <LinearLayout android:id="@+id/footer" android:layout_width="fill_parent" android:layout_height="90dip" android:background="@layout/pie_de_pagina" android:layout_alignParentBottom="true"> </LinearLayout> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="wrap_content" android:padding="10dip" android:layout_below="@id/header"> <TextView android:id="@+id/texto_no_tuyo" android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_marginTop="5dip" android:text="@string/dispositivo_no_es_tuyo" android:gravity="center" android:textSize="20dip" android:textColor="#6e1942"/>



Página 105

<TextView android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_marginTop="5dip" android:textColor="#6e1942" android:text="@string/password"/> <EditText android:id="@+id/perm_password" android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_marginTop="5dip" android:singleLine="true" android:inputType="textPassword"/> <Button android:id="@+id/btn_permitir" android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_marginTop="10dip" android:text="@string/permitir_dispositivo" android:onClick="permitir"/> <TextView android:id="@+id/link_no_gracias" android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_marginTop="40dip" android:layout_marginBottom="80dip" android:text="@string/no_gracias" android:gravity="center" android:textSize="20dip" android:textColor="#6e1942" android:onClick="noGracias" android:clickable="true"/> </LinearLayout> </RelativeLayout> </ScrollView>



Página 106

C.9 Código para el control del envío de datos del formulario de permiso de uso del

dispositivo.

package com.r2.mx.kajoolqr.app; import java.util.ArrayList; import java.util.List; import com.r2.mx.kajoolqr.app.ssl.AsistenteSocket; import com.r2.mx.kajoolqr.app.ssl.Parametro; import com.r2.mx.kajoolqr.app.ssl.SSL; import android.os.Bundle; import android.app.Activity; import android.content.Intent; import android.view.KeyEvent; import android.view.View; import android.widget.EditText; import android.widget.Toast; public class PermitirDispositivo extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.permitir_dispositivo); } /********************************************************** * * --- Método permitir --- * Este método funciona cuando el usuario da click en el * botón Permitir * * Recibe como parámetro un objeto de tipo View, de * acuerdo con la clase OnClickListener de android. * * El algoritmo de control para enviar los datos de * usuario es el siguiente: * -Comprueba que ambos passwords sean iguales, en * caso contrario, envía un mensaje para que el * usuario reingrese ambos. * -Reune los datos para el POST en una lista de * objetos Parametro. * -Conecta mediante sockets al servidor y envía * los parámetros. * -Recibe el mensaje del servidor. * -Crea un paquete Bundle que enviará a la * siguiente actividad. * -Introduce el mensaje recibido y la presente * actividad al paquete. * -Abre un Intent de la actividad Mensaje y le



Página 107

* envia el paquete. * -Termina el Intent de la presente actividad. * **********************************************************/ public void permitir(View view){ List<Parametro> parametros = reunirDatos(); String url = "https://r2rock.jelastic.servint.net/kajool/Permitir"; SSL socket = AsistenteSocket.conectar(parametros, url); String entrada = AsistenteSocket.recibeMensaje(socket); String mensaje = ""; if(entrada.contains("Error")){ mensaje = entrada; Toast.makeText(this, mensaje, Toast.LENGTH_LONG).show(); }else{ String[] datos = entrada.split(";"); Bundle bundle = new Bundle(); bundle.putString("idUsuario", datos[0]); bundle.putString("usuario", datos[1]); Intent i = new Intent(this, Menu.class); i.putExtras(bundle); startActivity(i); finish(); } } public void noGracias(View view){ finish(); } private List<Parametro> reunirDatos(){ Bundle bundle = getIntent().getExtras(); String usuario = bundle.getString("usuario"); String mac = bundle.getString("mac"); String password = ((EditText)findViewById(R.id.perm_password)).getText().toString(); List<Parametro> parametros = new ArrayList<Parametro>(); parametros.add(new Parametro("usuario", usuario)); parametros.add(new Parametro("mac", mac)); parametros.add(new Parametro("password", password)); return parametros; } @Override public boolean onKeyDown(int keyCode, KeyEvent event){ if ((keyCode == KeyEvent.KEYCODE_BACK)){ finish(); } return super.onKeyDown(keyCode, event); } }



Página 108

C.10 – Código para la creación del menú de opciones para el usuario.

<?xml version="1.0" encoding="utf-8"?> <ScrollView xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:fillViewport="true"> <RelativeLayout android:layout_width="fill_parent" android:layout_height="wrap_content" android:background="#fff"> <LinearLayout android:id="@+id/header" android:layout_width="fill_parent" android:layout_height="wrap_content" android:background="@layout/encabezado" android:paddingTop="5dip" android:paddingBottom="5dip"> <ImageView android:src="@drawable/logo_letras" android:contentDescription="@string/logo_descripcion" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginLeft="10dip"/> </LinearLayout> <LinearLayout android:id="@+id/footer" android:layout_width="fill_parent" android:layout_height="90dip" android:background="@layout/pie_de_pagina" android:layout_alignParentBottom="true"> </LinearLayout> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="wrap_content" android:padding="10dip" android:layout_below="@id/header"> <TextView android:id="@+id/hola_usuario" android:layout_width="fill_parent" android:layout_height="wrap_content" android:textColor="#6e1942"/> <TextView android:layout_width="fill_parent" android:layout_height="wrap_content" android:textColor="#6e1942" android:text="@string/instrucciones"/>



Página 109

<Button android:id="@+id/btn_firmar" android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_marginTop="10dip" android:text="@string/firmar" android:onClick="firmar"/> <Button android:id="@+id/btn_leer" android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_marginTop="10dip" android:layout_marginBottom="40dip" android:text="@string/leer" android:onClick="validar"/> <TextView android:id="@+id/link_cerrar_sesion" android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_marginTop="20dip" android:layout_marginBottom="80dip" android:text="@string/cerrar_sesion" android:gravity="center" android:textSize="20dip" android:textColor="#6e1942" android:onClick="cerrarSesion" android:clickable="true"/> </LinearLayout> </RelativeLayout> </ScrollView>



Página 110

C.11 Código para el control de la selección del usuario en el menú.

package com.r2.mx.kajoolqr.app; import java.util.ArrayList; import java.util.List; import com.r2.mx.kajoolqr.app.ssl.AsistenteSocket; import com.r2.mx.kajoolqr.app.ssl.Parametro; import com.r2.mx.kajoolqr.app.ssl.SSL; import android.net.wifi.WifiManager; import android.os.Bundle; import android.view.View; import android.widget.TextView; import android.widget.Toast; import android.app.Activity; import android.content.Context; import android.content.Intent; public class Menu extends Activity { private int idUsuario; private String usuario; private static final String SESION_CERRADA = "1"; private static final String ERROR = "0"; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.menu); TextView txtSaludo = (TextView)findViewById(R.id.hola_usuario); Bundle bundle = getIntent().getExtras(); idUsuario = Integer.parseInt(bundle.getString("idUsuario")); usuario = bundle.getString("usuario"); txtSaludo.setText("Hola "+usuario); } public void firmar(View view){ Intent i = new Intent(this, SelectorArchivos.class); Bundle bundle = new Bundle(); bundle.putString("idUsuario", String.valueOf(idUsuario)); bundle.putString("usuario", usuario); i.putExtras(bundle); startActivity(i); finish();



Página 111

} public void validar(View view){ Intent i = new Intent("com.google.zxing.client.android.SCAN"); i.setPackage("com.google.zxing.client.android"); Bundle bundle = new Bundle(); bundle.putString("idUsuario", String.valueOf(idUsuario)); bundle.putString("SCAN_MODE", "QR_CODE_MODE"); i.putExtras(bundle); startActivityForResult(i, 0); } public void cerrarSesion(View view){ String mac = ((WifiManager)this.getSystemService(Context.WIFI_SERVICE)).getConnectionInfo().getMacAddress(); List<Parametro> parametros = new ArrayList<Parametro>(); parametros.add(new Parametro("mac", mac)); String url = "https://r2rock.jelastic.servint.net/kajool/Logoff"; SSL socket = AsistenteSocket.conectar(parametros, url); String entrada = AsistenteSocket.recibeMensaje(socket); if(entrada.startsWith(ERROR)){ String[] datos = entrada.split(";"); Toast.makeText(this, datos[1], Toast.LENGTH_SHORT).show(); }else if(entrada.equals(SESION_CERRADA)){ String mensaje = "Sesion cerrada. ¡Hasta luego "+usuario+"!"; Toast.makeText(this, mensaje, Toast.LENGTH_SHORT).show(); finish(); }else{ Toast.makeText(this, entrada, Toast.LENGTH_SHORT).show(); finish(); } } public void onActivityResult(int requestCode, int resultCode, Intent intent) { if (requestCode == 0) { if (resultCode == RESULT_OK) { String resultado = intent.getStringExtra("SCAN_RESULT"); Toast.makeText(this, resultado, Toast.LENGTH_SHORT).show(); List<Parametro> parametros = new ArrayList<Parametro>(); parametros.add(new Parametro("cifrado", resultado)); String url = "https://r2rock.jelastic.servint.net/kajool/Desencriptar"; SSL socket = AsistenteSocket.conectar(parametros, url); String firma = AsistenteSocket.recibeMensaje(socket); Intent i = new Intent(this, Mensaje.class); Bundle bundle = new Bundle();



Página 112

bundle.putString("mensaje", firma); bundle.putString("actividad", "Menu"); bundle.putString("idUsuario", String.valueOf(idUsuario)); bundle.putString("usuario", usuario); i.putExtras(bundle); startActivity(i); finish(); } else if (resultCode == RESULT_CANCELED) { finish(); } } } }



Página 113

C.12 – Código para la creación de la interfaz de la selección de documento.

<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="wrap_content" android:layout_height="wrap_content" android:padding="10dip"> <TextView android:text="@+id/TextView01" android:id="@+id/TextView01" android:layout_width="wrap_content" android:layout_height="wrap_content" android:singleLine="true" android:textStyle="bold" android:layout_marginTop="5dip" android:layout_marginLeft="5dip"> </TextView> <TextView android:text="@+id/TextView02" android:id="@+id/TextView02" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginLeft="10dip"> </TextView> </LinearLayout>



Página 114

C.13 – Código para el control y el envío de la selección del archivo.

package com.r2.mx.kajoolqr.app; import java.io.File; import java.util.ArrayList; import java.util.Collections; import java.util.List; import com.r2.mx.kajoolqr.app.herramientas.Convertidor; import com.r2.mx.kajoolqr.app.selector.Opcion; import com.r2.mx.kajoolqr.app.ssl.AsistenteSocket; import com.r2.mx.kajoolqr.app.ssl.Parametro; import com.r2.mx.kajoolqr.app.ssl.SSL; import android.app.AlertDialog; import android.app.ListActivity; import android.content.DialogInterface; import android.content.Intent; import android.os.Bundle; import android.os.Environment; import android.view.KeyEvent; import android.view.View; import android.widget.ListView; import android.widget.Toast; public class SelectorArchivos extends ListActivity{ private File directorioActual; private int idUsuario; private String usuario; private AdaptadorArregloArchivos adaptador; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Bundle bundle = getIntent().getExtras(); idUsuario = Integer.parseInt(bundle.getString("idUsuario")); usuario = bundle.getString("usuario"); directorioActual = new File(Environment.getExternalStorageDirectory().getPath()); llena(directorioActual); } private void llena(File f){ File[]dirs = f.listFiles(); this.setTitle("Directorio Actual: "+f.getName());



Página 115

List<Opcion>dir = new ArrayList<Opcion>(); List<Opcion>fls = new ArrayList<Opcion>(); try{ for(File ff: dirs){ String nombre = ff.getName(); if(ff.isDirectory()){ if(!nombre.startsWith(".")) if(!nombre.endsWith(".DIR")) dir.add(new Opcion(nombre,"Folder",ff.getAbsolutePath())); }else{ String extension = ""; int i = nombre.lastIndexOf('.'); if (i > 0) { extension = nombre.substring(i+1); } if(extension.equalsIgnoreCase("pdf")) fls.add(new Opcion(nombre,"Tamaño del archivo: "+ff.length(),ff.getAbsolutePath())); } } }catch(Exception e){ } Collections.sort(dir); Collections.sort(fls); dir.addAll(fls); if(!f.getName().equalsIgnoreCase("sdcard")) dir.add(0,new Opcion("..","Parent Directory",f.getParent())); adaptador = new AdaptadorArregloArchivos(SelectorArchivos.this,R.layout.archivo,dir); this.setListAdapter(adaptador); } @Override protected void onListItemClick(ListView l, View v, int position, long id) { super.onListItemClick(l, v, position, id); Opcion o = adaptador.getItem(position); if(o.getDato().equalsIgnoreCase("folder")||o.getDato().equalsIgnoreCase("parent directory")){ directorioActual = new File(o.getRuta()); llena(directorioActual); } else onFileClick(o); }



Página 116

private void onFileClick(final Opcion o){ DialogInterface.OnClickListener dialogClickListener = new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) { switch (which){ case DialogInterface.BUTTON_POSITIVE: String resumen = Convertidor.resumirArchivo(o.getRuta()); //Encriptar List<Parametro> parametros = new ArrayList<Parametro>(); parametros.add(new Parametro("idUsuario", String.valueOf(idUsuario))); parametros.add(new Parametro("nombreArchivo", o.getNombre())); parametros.add(new Parametro("hash", resumen)); String url = "https://r2rock.jelastic.servint.net/kajool/Encriptar"; SSL socket = AsistenteSocket.conectar(parametros, url); String entrada = AsistenteSocket.recibeMensaje(socket); Toast.makeText(getApplicationContext(), entrada, Toast.LENGTH_SHORT).show(); // Intent intent = new Intent("com.google.zxing.client.android.ENCODE"); intent.putExtra("ENCODE_TYPE", "TEXT_TYPE"); intent.putExtra("ENCODE_DATA", entrada); startActivity(intent); break; case DialogInterface.BUTTON_NEGATIVE: // } } }; AlertDialog.Builder constructor = new AlertDialog.Builder(this); constructor.setMessage("¿Estás seguro de firmar "+o.getNombre()+"?"); constructor.setPositiveButton("Si", dialogClickListener); constructor.setNegativeButton("No", dialogClickListener); constructor.show(); } @Override public boolean onKeyDown(int keyCode, KeyEvent event){ if (keyCode == KeyEvent.KEYCODE_BACK){ Bundle bundle = new Bundle(); bundle.putString("idUsuario", String.valueOf(idUsuario)); bundle.putString("usuario", usuario); Intent i = new Intent(this, Menu.class); i.putExtras(bundle); startActivity(i); finish();



Página 117

} return super.onKeyDown(keyCode, event); } } package com.r2.mx.kajoolqr.app; import java.util.List; import com.r2.mx.kajoolqr.app.selector.Opcion; import android.content.Context; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; import android.widget.ArrayAdapter; import android.widget.TextView; public class AdaptadorArregloArchivos extends ArrayAdapter<Opcion>{ private Context c; private int id; private List<Opcion>items; public AdaptadorArregloArchivos(Context context, int recursoId, List<Opcion> objetos) { super(context, recursoId, objetos); c = context; id = recursoId; items = objetos; } public Opcion getItem(int i){ return items.get(i); } @Override public View getView(int position, View convertView, ViewGroup parent) { View v = convertView; if (v == null) { LayoutInflater vi = (LayoutInflater)c.getSystemService(Context.LAYOUT_INFLATER_SERVICE); v = vi.inflate(id, null); }



Página 118

final Opcion o = items.get(position); if (o != null) { TextView t1 = (TextView) v.findViewById(R.id.TextView01); TextView t2 = (TextView) v.findViewById(R.id.TextView02); if(t1!=null) t1.setText(o.getNombre()); if(t2!=null) t2.setText(o.getDato()); } return v; } } package com.r2.mx.kajoolqr.app.selector; public class Opcion implements Comparable<Opcion>{ private String nombre; private String dato; private String ruta; public Opcion(String n,String d,String p){ nombre = n; dato = d; ruta = p; } public String getNombre(){ return nombre; } public String getDato(){ return dato; } public String getRuta(){ return ruta; } public int compareTo(Opcion o) { if(this.nombre != null) return this.nombre.toLowerCase().compareTo(o.getNombre().toLowerCase()); else throw new IllegalArgumentException(); } }



Página 119



Página 120

D. Anexo – Códigos de la programación del servidor.



Página 121

D.1 – Código para la conexión a la base de datos de MySQL

package com.r2.mx.kajoolqr.web.conexion.herramientas; import java.io.FileInputStream; import java.io.IOException; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import java.util.Properties; public class ConexionBD { private String error; public Connection conexion; public Statement sentencia; public ResultSet resultado; public ConexionBD(){ conexion = null; sentencia = null; resultado = null; error = null; try { Properties prop = new Properties(); prop.load(new FileInputStream(System.getProperty("user.home") + "/mydb.cfg")); String driver = prop.getProperty("driver").toString(); String host = prop.getProperty("host").toString(); String usuario = prop.getProperty("username").toString(); String password = prop.getProperty("password").toString(); Class.forName(driver); conexion =DriverManager.getConnection(host, usuario, password); sentencia = conexion.createStatement(); }catch(SQLException e){ error = "Excepcion SQL en Conexion: "+e.getMessage(); }catch(ClassNotFoundException e){ error = "Excepcion ClassNotFound en Conexion: "+e.getMessage(); }catch(IOException e){ error = "Excepcion IO en Conexion: "+e.getMessage(); } } public void ejecutaInterrogante(String query){



Página 122

try{ resultado = sentencia.executeQuery(query); }catch(SQLException e){ error = "Excepcion SQL en Conexion: "+e.getMessage(); }catch(NullPointerException e){ error = "Excepcion NullPointer en Conexion: "+e.getMessage(); } } public void ejecutaActualizacion(String sql){ try{ sentencia.executeUpdate(sql); }catch(SQLException e){ error = "Excepcion SQL en Conexion: "+e.getMessage(); }catch(NullPointerException e){ error = "Excepcion NullPointer en Conexion: "+e.getMessage(); } } public void terminaConexion(){ try{ if(resultado != null) { resultado.close(); resultado = null; } if(sentencia != null) { sentencia.close(); sentencia = null; } if(conexion != null) { conexion.close(); conexion = null; } }catch(SQLException e){ error = "Excepcion SQL en Conexion: "+e.getMessage(); } } public String getError() { return error; } }



Página 123

D.2 – Código para realizar las consultas a la base de datos

package com.r2.mx.kajoolqr.web.conexion.herramientas; import java.sql.SQLException; import com.r2.mx.kajoolqr.web.conexion.objetos.Dispositivo; import com.r2.mx.kajoolqr.web.conexion.objetos.Usuario; public class Consultas { public final static String consultaSimplePorId(ConexionBD conexion, String tabla, String columna, String condicionante, int id){ String query = "SELECT "+columna+" FROM "+tabla+" WHERE "+condicionante+"="+id; conexion.ejecutaInterrogante(query); String valor = ""; try{ if(conexion.resultado.next()) valor = (String)conexion.resultado.getObject(1); else valor = "Error: Nulo"; }catch(SQLException e){ valor = "Error: "+e.getMessage(); } return valor; } public final static Usuario buscaUsuarioPorNombre(ConexionBD conexion, String usr){ String query = "SELECT * FROM usuarios where nombre_usuario='"+usr+"'"; conexion.ejecutaInterrogante(query); Usuario usuario = new Usuario(conexion.resultado); if(conexion.getError()== null){ if(usuario.getError() == null) return usuario; else return null; }else return null; } public final static Usuario buscaUsuarioPorId(ConexionBD conexion, int idUsuario){ String query = "SELECT * FROM usuarios where id_usuario="+idUsuario; conexion.ejecutaInterrogante(query); Usuario usuario = new Usuario(conexion.resultado); if(conexion.getError()== null){



Página 124

if(usuario.getError() == null) return usuario; else return null; }else return null; } public final static Dispositivo buscaDispositivoPorMac(ConexionBD conexion, String mac){ String query = "SELECT * FROM dispositivos where mac='"+mac+"'"; conexion.ejecutaInterrogante(query); Dispositivo dispositivo = new Dispositivo(conexion.resultado); if(conexion.getError()== null){ if(dispositivo.getError() == null) return dispositivo; else return null; }else return null; } public final static String buscaFirma(ConexionBD conexion, String clave){ String query = "SELECT firma FROM firmas where clave='"+clave+"'"; conexion.ejecutaInterrogante(query); String firma = null; try{ if(conexion.resultado.next()) firma = (String)conexion.resultado.getObject(1); }catch(SQLException e){ firma = "Error: "+e.getMessage(); } return firma; } }



Página 125

D.3 Código para hacer las operaciones sobre la base de datos.

package com.r2.mx.kajoolqr.web.conexion.herramientas; import java.util.Date; import com.r2.mx.kajoolqr.web.conexion.objetos.Dispositivo; import com.r2.mx.kajoolqr.web.conexion.objetos.Usuario; public class Operaciones { private final static boolean verificarOperacion(String error){ boolean exito = false; if(error == null) exito = true; return exito; } /************************ Usuarios ************************/ public final static boolean registrarUsuario(Usuario usuario, ConexionBD conexion){ String sql = "INSERT INTO usuarios"; sql += "(nombre_usuario, nombre_completo, titulo, pass, email, activo) "; sql += "VALUES ('"+usuario.getNombreUsuario()+"',"; sql += "'"+usuario.getNombreCompleto()+"',"; sql += "'"+usuario.getTitulo()+"',"; sql += "'"+usuario.getPassword()+"',"; sql += "'"+usuario.getEmail()+"',"; sql += "1)"; conexion.ejecutaActualizacion(sql); return verificarOperacion(conexion.getError()); } /********************** Dispositivo **********************/ public final static boolean registrarDispositivo(int idUsuario, String mac, int sesion, ConexionBD conexion){ String hora = new Date().toString(); String sql = "INSERT INTO dispositivos"; sql += "(id_usuario, mac, sesion, id_usuario_sesion, hora_sesion) VALUES ("; sql += idUsuario+",'"+mac+"',"+sesion+","+idUsuario+",'"+hora+"')"; conexion.ejecutaActualizacion(sql); return verificarOperacion(conexion.getError()); }



Página 126

public final static boolean registrarSesion(Usuario usuario, Dispositivo dispositivo, String hora, ConexionBD conexion){ String sql = "UPDATE dispositivos SET sesion=1, "; sql += "id_usuario_sesion="+usuario.getIdUsuario()+","; sql += "hora_sesion='"+hora+"' "; sql += "WHERE mac='"+dispositivo.getMac()+"'"; conexion.ejecutaActualizacion(sql); return verificarOperacion(conexion.getError()); } public final static boolean invalidarSesion(String mac, ConexionBD conexion){ String sql = "UPDATE dispositivos SET sesion=0 WHERE mac='"+mac+"'"; conexion.ejecutaActualizacion(sql); return verificarOperacion(conexion.getError()); } public final static boolean insertarFirma(String clave, String firma, ConexionBD conexion){ String sql = "INSERT INTO firmas (clave, firma) VALUES ('"; sql += clave+"','"+firma+"')"; conexion.ejecutaActualizacion(sql); return verificarOperacion(conexion.getError()); } }



Página 127

D.4 – Código que contiene a la entidad Usuario

package com.r2.mx.kajoolqr.web.conexion.objetos; import java.sql.ResultSet; import java.sql.SQLException; import javax.servlet.http.HttpServletRequest; import com.r2.mx.kajoolqr.web.encriptacion.Encriptacion; public class Usuario { private int idUsuario; private String nombreUsuario; private String nombreCompleto; private String titulo; private String password; private String email; private int activo; private String error; public Usuario(int idUsuario, String nombreUsuario, String nombreCompleto, String titulo, String password, String email, int activo){ this.idUsuario = idUsuario; this.nombreUsuario = nombreUsuario; this.nombreCompleto = nombreCompleto; this.titulo = titulo; this.password = password; this.email = email; this.activo = activo; error = null; } public Usuario(String nombreUsuario, String nombreCompleto, String titulo, String password, String email, int activo){ this.nombreUsuario = nombreUsuario; this.nombreCompleto = nombreCompleto; this.titulo = titulo; this.password = password; this.email = email; this.activo = activo; error = null; } public Usuario(String nombreUsuario, String password){



Página 128

this.nombreUsuario = nombreUsuario; this.password = password; error = null; } public Usuario(ResultSet resultados){ try{ if(resultados.next()){ idUsuario = (Integer)resultados.getObject(1); nombreUsuario = (String)resultados.getObject(2); nombreCompleto = (String)resultados.getObject(3); titulo = (String)resultados.getObject(4); password = (String)resultados.getObject(5); email = (String)resultados.getObject(6); activo = (Integer)resultados.getObject(7); error = null; }else{ error = "Nulo"; } }catch(SQLException e){ error = "Excepcion SQL en objeto Usuario= "+e.getMessage(); } } public Usuario(HttpServletRequest request){ nombreUsuario = request.getParameter("usuario"); nombreCompleto = request.getParameter("nombre"); titulo = request.getParameter("titulo"); String pass = request.getParameter("password"); password = Encriptacion.getStringMessageDigest(pass, Encriptacion.MD5); email = request.getParameter("email"); error = null; } public void setIdUsuario(int idUsuario) { this.idUsuario = idUsuario; } public void setNombreUsuario(String nombreUsuario) { this.nombreUsuario = nombreUsuario; } public void setNombreCompleto(String nombreCompleto) { this.nombreCompleto = nombreCompleto; }



Página 129

public void setTitulo(String titulo) { this.titulo = titulo; } public void setPassword(String password) { this.password = password; } public void setEmail(String email) { this.email = email; } public void setActivo(int activo) { this.activo = activo; } public void setError(String error) { this.error = error; } public int getIdUsuario() { return idUsuario; } public String getNombreUsuario() { return nombreUsuario; } public String getPassword() { return password; } public String getNombreCompleto() { return nombreCompleto; } public String getTitulo() { return titulo; } public String getEmail() { return email; } public int getActivo() { return activo;



Página 130

} public String getError(){ return error; } }



Página 131

D.5 – Código que contiene a la entidad Dispositivo

package com.r2.mx.kajoolqr.web.conexion.objetos; import java.sql.ResultSet; import java.sql.SQLException; import javax.servlet.http.HttpServletRequest; import com.r2.mx.kajoolqr.web.encriptacion.Encriptacion; public class Dispositivo { private int idDispositivo; private int idUsuario; private String mac; private int sesion; private int idUsuarioSesion; private String horaSesion; private String error; public Dispositivo(int idDispositivo, int idUsuario, String mac){ this.idDispositivo = idDispositivo; this.idUsuario = idUsuario; this.mac = mac; error = null; } public Dispositivo(String mac){ this.mac = mac; error = null; } public Dispositivo(ResultSet resultados){ try{ if(resultados.next()){ idDispositivo = (Integer)resultados.getObject(1); idUsuario = (Integer)resultados.getObject(2); mac = (String)resultados.getObject(3); sesion = (Integer)resultados.getObject(4); idUsuarioSesion = (Integer)resultados.getObject(5); if(resultados.getObject(6)!=null) horaSesion = (String)resultados.getObject(6); error = null; }else{ error = "Nulo";



Página 132

} }catch(SQLException e){ error = "Excepcion SQL en objeto Usuario= "+e.getMessage(); } } public Dispositivo (HttpServletRequest request){ String mac = request.getParameter("mac"); mac = Encriptacion.getStringMessageDigest(mac, Encriptacion.MD5); this.mac = mac; error = null; } public int getIdDispositivo(){ return this.idDispositivo; } public int getIdUsuario(){ return this.idUsuario; } public String getMac(){ return this.mac; } public int getSesion() { return sesion; } public int getIdUsuarioSesion() { return idUsuarioSesion; } public String getHoraSesion() { return horaSesion; } public String getError() { return error; } }



Página 133

D.6 – Código que contiene el algoritmo de encriptación DES

package com.r2.mx.kajoolqr.web.encriptacion; import java.security.spec.AlgorithmParameterSpec; import java.security.spec.KeySpec; import javax.crypto.*; import javax.crypto.spec.*; import java.io.*; public class DataEncryptionStandard { private Cipher ecipher; private Cipher dcipher; // 8-byte Salt private byte[] salt = {(byte)0xA9, (byte)0x9B, (byte)0xC8, (byte)0x32, (byte)0x56, (byte)0x35, (byte)0xE3, (byte)0x03}; // Iteration count private int iterationCount = 19; public DataEncryptionStandard(String passPhrase) { try { // Create the key KeySpec keySpec = new PBEKeySpec(passPhrase.toCharArray(), salt, iterationCount); SecretKey key = SecretKeyFactory.getInstance("PBEWithMD5AndDES").generateSecret(keySpec); ecipher = Cipher.getInstance(key.getAlgorithm()); dcipher = Cipher.getInstance(key.getAlgorithm()); // Prepare the parameter to the ciphers AlgorithmParameterSpec paramSpec = new PBEParameterSpec(salt, iterationCount); // Create the ciphers ecipher.init(Cipher.ENCRYPT_MODE, key, paramSpec); dcipher.init(Cipher.DECRYPT_MODE, key, paramSpec); } catch (java.security.InvalidAlgorithmParameterException e) { } catch (java.security.spec.InvalidKeySpecException e) { } catch (javax.crypto.NoSuchPaddingException e) { } catch (java.security.NoSuchAlgorithmException e) {



Página 134

} catch (java.security.InvalidKeyException e) { } } public String encrypt(String str) { try { // Encode the string into bytes using utf-8 byte[] utf8 = str.getBytes("UTF8"); // Encrypt byte[] enc = ecipher.doFinal(utf8); // Encode bytes to base64 to get a string return new sun.misc.BASE64Encoder().encode(enc); } catch (javax.crypto.BadPaddingException e) { } catch (IllegalBlockSizeException e) { } catch (UnsupportedEncodingException e) { } return null; } public String decrypt(String str) { try { // Decode base64 to get bytes byte[] dec = new sun.misc.BASE64Decoder().decodeBuffer(str); // Decrypt byte[] utf8 = dcipher.doFinal(dec); // Decode using utf-8 return new String(utf8, "UTF8"); } catch (javax.crypto.BadPaddingException e) { } catch (IllegalBlockSizeException e) { } catch (UnsupportedEncodingException e) { } catch (java.io.IOException e) { } return null; } }



Página 135

D.7 – Código que contiene la encriptación MD5

package com.r2.mx.kajoolqr.web.encriptacion; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; public class Encriptacion { public static String MD5 = "MD5"; private static String toHexadecimal(byte[] digest){ String hash = ""; for(byte aux : digest) { int b = aux & 0xff; if (Integer.toHexString(b).length() == 1) hash += "0"; hash += Integer.toHexString(b); } return hash; } public static String getStringMessageDigest(String message, String algorithm){ byte[] digest = null; byte[] buffer = message.getBytes(); try { MessageDigest messageDigest = MessageDigest.getInstance(algorithm); messageDigest.reset(); messageDigest.update(buffer); digest = messageDigest.digest(); } catch (NoSuchAlgorithmException ex) { System.out.println("Error creando Digest"); } return toHexadecimal(digest); } }



Página 136

D.8 – Código que genera la clave que se mostrará en el código QR.

package com.r2.mx.kajoolqr.web.encriptacion; import com.r2.mx.kajoolqr.web.conexion.herramientas.ConexionBD; import com.r2.mx.kajoolqr.web.conexion.herramientas.Consultas; public class Generador { public final static String generaTextoFirma(){ int titulo, primerNombre, segundoNombre, primerApellido, segundoApellido; titulo = (int) (Math.random()*15+1); if(titulo == 5){ primerNombre = (int) (Math.random()*352+323); segundoNombre = (int) (Math.random()*352+323); }else{ primerNombre = (int) (Math.random()*674+1); if(primerNombre < 322) segundoNombre = (int) (Math.random()*322+1); else segundoNombre = (int) (Math.random()*352+323); } primerApellido = (int) (Math.random()*135+1); segundoApellido = (int) (Math.random()*135+1); String cadena = ""; ConexionBD conexion = new ConexionBD(); cadena += Consultas.consultaSimplePorId(conexion, "titulos", "titulo", "id_titulo", titulo)+" "; cadena += Consultas.consultaSimplePorId(conexion, "nombres", "nombre", "id_nombre", primerNombre)+ " "; cadena += Consultas.consultaSimplePorId(conexion, "nombres", "nombre", "id_nombre", segundoNombre)+ " "; cadena += Consultas.consultaSimplePorId(conexion, "apellidos", "apellido", "id_apellido", primerApellido)+ " "; cadena += Consultas.consultaSimplePorId(conexion, "apellidos", "apellido", "id_apellido", segundoApellido)+ " "; conexion.terminaConexion(); return cadena; } }



Página 137

D.8 – Código que hará el registro en la base de datos.

package com.r2.mx.kajoolqr.web.conexion; import java.io.IOException; import java.io.PrintWriter; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import com.r2.mx.kajoolqr.web.conexion.herramientas.ConexionBD; import com.r2.mx.kajoolqr.web.conexion.herramientas.Consultas; import com.r2.mx.kajoolqr.web.conexion.herramientas.Operaciones; import com.r2.mx.kajoolqr.web.conexion.objetos.Dispositivo; import com.r2.mx.kajoolqr.web.conexion.objetos.Usuario; public class Registrar extends HttpServlet { private static final long serialVersionUID = 1L; private static final String TIPO_CONTENIDO = "text/html; charset=windows-1252"; private static final String TIPO_CODIFICACION = "utf-8"; private static final String USUARIO_Y_DISPOSITIVO_LIBRES = "A"; private static final String USUARIO_NO_LIBRE = "B"; private static final String DISPOSITIVO_NO_LIBRE = "C"; private static final String DISPOSITIVO_GUARDADO = "1"; private static final String DISPOSITIVO_NO_GUARDADO = "0"; public Registrar() { super(); } protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { manejaPeticion(request, response); } protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { manejaPeticion(request, response); } private void manejaPeticion(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{ String opcion = request.getParameter("opcion"); response.setContentType(TIPO_CONTENIDO);



Página 138

response.setContentType(TIPO_CODIFICACION); PrintWriter out = response.getWriter(); ConexionBD conexion = new ConexionBD(); String mensaje = null; if(opcion.equals("usuario")) mensaje = registrarUsuario(request, conexion); else if(opcion.equals("dispositivo")) mensaje = registrarDispositivo(request, conexion); conexion.terminaConexion(); out.print(mensaje); out.close(); } private String registrarUsuario(HttpServletRequest request, ConexionBD conexion){ Usuario usuarioFrm = new Usuario(request); Dispositivo dispositivoFrm = new Dispositivo(request); Usuario usuario = Consultas.buscaUsuarioPorNombre(conexion, usuarioFrm.getNombreUsuario()); String mensaje = ""; if(usuario != null){ mensaje = USUARIO_NO_LIBRE; }else{ Operaciones.registrarUsuario(usuarioFrm, conexion); if(conexion.getError() == null){ Dispositivo dispositivo = Consultas.buscaDispositivoPorMac(conexion, dispositivoFrm.getMac()); if(dispositivo != null) mensaje = DISPOSITIVO_NO_LIBRE; else{ usuario = Consultas.buscaUsuarioPorNombre(conexion, usuarioFrm.getNombreUsuario()); Operaciones.registrarDispositivo(usuario.getIdUsuario(), dispositivoFrm.getMac(), 0, conexion); if(conexion.getError() == null) mensaje = USUARIO_Y_DISPOSITIVO_LIBRES; else mensaje = "Error: " + conexion.getError(); } }else mensaje = "Error: "+conexion.getError(); } return mensaje; } private String registrarDispositivo(HttpServletRequest request, ConexionBD conexion){ String idUsuario = request.getParameter("idUsuario");



Página 139

String nombreUsuario = request.getParameter("nombreUsuario"); String mac = request.getParameter("mac"); Operaciones.registrarDispositivo(Integer.parseInt(idUsuario), mac,1, conexion); String mensaje = ""; if(conexion.getError() == null) mensaje = DISPOSITIVO_GUARDADO+";"+idUsuario+";"+nombreUsuario; else mensaje = DISPOSITIVO_NO_GUARDADO+";"+idUsuario+";"+nombreUsuario; return mensaje; } }



Página 140

D.9 – Código para el inicio de sesión

package com.r2.mx.kajoolqr.web.conexion; import java.io.IOException; import java.io.PrintWriter; import java.text.DateFormat; import java.text.SimpleDateFormat; import java.util.Date; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import com.r2.mx.kajoolqr.web.conexion.herramientas.ConexionBD; import com.r2.mx.kajoolqr.web.conexion.herramientas.Consultas; import com.r2.mx.kajoolqr.web.conexion.herramientas.Operaciones; import com.r2.mx.kajoolqr.web.conexion.objetos.Dispositivo; import com.r2.mx.kajoolqr.web.conexion.objetos.Usuario; public class Login extends HttpServlet { private static final long serialVersionUID = 1L; private static final String TIPO_CONTENIDO = "text/html; charset=windows-1252"; private static final String TIPO_CODIFICACION = "utf-8"; private static final String CORRECTA_IDENTIFICACION = "A"; private static final String DISPOSITIVO_PRESTADO = "B"; private static final String USUARIO_PWD_INCORRECTOS = "C"; private static final String DISPOSITIVO_NO_REGISTRADO = "D"; public Login() { super(); } protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { manejaPeticion(request, response); } protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { manejaPeticion(request, response); } private void manejaPeticion(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{



Página 141

Usuario usuarioForm = new Usuario(request); Dispositivo dispositivoForm = new Dispositivo(request); DateFormat formatter = new SimpleDateFormat("kk:mm:ss"); String hora = formatter.format(new Date()); response.setContentType(TIPO_CONTENIDO); response.setCharacterEncoding(TIPO_CODIFICACION); PrintWriter out = response.getWriter(); ConexionBD conexion = new ConexionBD(); String mensaje = null; Usuario usuario = Consultas.buscaUsuarioPorNombre(conexion, usuarioForm.getNombreUsuario()); Dispositivo dispositivo = Consultas.buscaDispositivoPorMac(conexion, dispositivoForm.getMac()); if(usuario != null){ if(usuario.getPassword().equals(usuarioForm.getPassword()) && usuario.getActivo() == 1){ if(dispositivo != null){ if(usuario.getIdUsuario()==dispositivo.getIdUsuario()){ Operaciones.registrarSesion(usuario, dispositivo, hora, conexion); if(conexion.getError() == null) mensaje = CORRECTA_IDENTIFICACION+";"+usuario.getIdUsuario()+";"+usuario.getNombreUsuario(); else mensaje = "Error: " + conexion.getError(); }else{ mensaje = DISPOSITIVO_PRESTADO+";"+dispositivo.getIdUsuario(); } }else{ mensaje = DISPOSITIVO_NO_REGISTRADO+";"+usuario.getIdUsuario()+";"; mensaje += usuario.getNombreUsuario()+";"+dispositivoForm.getMac(); } }else mensaje = USUARIO_PWD_INCORRECTOS; }else mensaje = USUARIO_PWD_INCORRECTOS; conexion.terminaConexion(); out.print(mensaje); out.close(); } }



Página 142

D.10 – Código para el permiso de uso del dispositivo en caso de no ser el dueño.

package com.r2.mx.kajoolqr.web.conexion; import java.io.IOException; import java.io.PrintWriter; import java.text.DateFormat; import java.text.SimpleDateFormat; import java.util.Date; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import com.r2.mx.kajoolqr.web.conexion.herramientas.ConexionBD; import com.r2.mx.kajoolqr.web.conexion.herramientas.Consultas; import com.r2.mx.kajoolqr.web.conexion.herramientas.Operaciones; import com.r2.mx.kajoolqr.web.conexion.objetos.Dispositivo; import com.r2.mx.kajoolqr.web.conexion.objetos.Usuario; import com.r2.mx.kajoolqr.web.encriptacion.Encriptacion; public class Permitir extends HttpServlet { private static final long serialVersionUID = 1L; private static final String TIPO_CONTENIDO = "text/html; charset=windows-1252"; private static final String TIPO_CODIFICACION = "utf-8"; public Permitir() { super(); } protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { manejaPeticion(request, response); } protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { manejaPeticion(request, response); } private void manejaPeticion(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{ String usr = request.getParameter("usuario"); String mac = request.getParameter("mac");



Página 143

String password = request.getParameter("password"); mac = Encriptacion.getStringMessageDigest(mac, Encriptacion.MD5); password = Encriptacion.getStringMessageDigest(password, Encriptacion.MD5); DateFormat formateador = new SimpleDateFormat("kk:mm:ss"); String hora = formateador.format(new Date()); response.setContentType(TIPO_CONTENIDO); response.setCharacterEncoding(TIPO_CODIFICACION); PrintWriter out = response.getWriter(); ConexionBD conexion = new ConexionBD(); Usuario usuario = Consultas.buscaUsuarioPorNombre(conexion, usr); Dispositivo dispositivo = Consultas.buscaDispositivoPorMac(conexion, mac); String mensaje = null; if(usuario != null){ if(dispositivo != null){ Usuario duenho = Consultas.buscaUsuarioPorId(conexion, dispositivo.getIdUsuario()); if(duenho != null){ if(duenho.getPassword().equals(password)){ if(Operaciones.registrarSesion(usuario, dispositivo, hora, conexion)) mensaje = usuario.getIdUsuario()+";"+usuario.getNombreUsuario(); else mensaje = "Error: "+conexion.getError(); } }else mensaje= "Error: dueño no registrado"; }else mensaje = "Error: dispositivo no registrado"; }else mensaje = "Error: usuario no registrado"; conexion.terminaConexion(); out.print(mensaje); out.close(); } }



Página 144

D.11 – Código para el cierre de sesión.

package com.r2.mx.kajoolqr.web.conexion; import java.io.IOException; import java.io.PrintWriter; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import com.r2.mx.kajoolqr.web.conexion.herramientas.ConexionBD; import com.r2.mx.kajoolqr.web.conexion.herramientas.Operaciones; import com.r2.mx.kajoolqr.web.encriptacion.Encriptacion; public class Logoff extends HttpServlet { private static final long serialVersionUID = 1L; private static final String TIPO_CONTENIDO = "text/html; charset=windows-1252"; private static final String TIPO_CODIFICACION = "utf-8"; private static final String SESION_CERRADA = "1"; private static final String ERROR = "0"; public Logoff() { super(); } protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { manejaPeticion(request, response); } protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { manejaPeticion(request, response); } private void manejaPeticion(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{ String mac = request.getParameter("mac"); mac = Encriptacion.getStringMessageDigest(mac, Encriptacion.MD5); response.setContentType(TIPO_CONTENIDO); response.setCharacterEncoding(TIPO_CODIFICACION); PrintWriter out = response.getWriter(); ConexionBD conexion = new ConexionBD(); String mensaje = "";



Página 145

if(Operaciones.invalidarSesion(mac, conexion)) mensaje = SESION_CERRADA; else mensaje = ERROR+";"+conexion.getError(); conexion.terminaConexion(); out.print(mensaje); out.close(); } }



Página 146

D.12 – Código para la encriptación de la firma procesada en el servidor

package com.r2.mx.kajoolqr.web.conexion; import java.io.IOException; import java.io.PrintWriter; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import com.r2.mx.kajoolqr.web.conexion.herramientas.ConexionBD; import com.r2.mx.kajoolqr.web.conexion.herramientas.Consultas; import com.r2.mx.kajoolqr.web.conexion.herramientas.Operaciones; import com.r2.mx.kajoolqr.web.conexion.objetos.Usuario; import com.r2.mx.kajoolqr.web.encriptacion.DataEncryptionStandard; import com.r2.mx.kajoolqr.web.encriptacion.Generador; public class Encriptar extends HttpServlet { private static final long serialVersionUID = 1L; private static final String TIPO_CONTENIDO = "text/html; charset=windows-1252"; private static final String TIPO_CODIFICACION = "utf-8"; public Encriptar() { super(); } protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { manejaPeticion(request, response); } protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { manejaPeticion(request, response); } private void manejaPeticion(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{ String idUsuario = request.getParameter("idUsuario"); String nombreArchivo = request.getParameter("nombreArchivo"); //String resumen = request.getParameter("hash"); response.setContentType(TIPO_CONTENIDO); response.setCharacterEncoding(TIPO_CODIFICACION); PrintWriter out = response.getWriter();



Página 147

ConexionBD conexion = new ConexionBD(); String mensaje = ""; Usuario usuario = Consultas.buscaUsuarioPorId(conexion, Integer.parseInt(idUsuario)); String clave = Generador.generaTextoFirma(); mensaje = "Archivo: "+nombreArchivo+";;"; mensaje += "Firmado por: "+usuario.getTitulo()+" "+usuario.getNombreCompleto(); DataEncryptionStandard encriptador = new DataEncryptionStandard(clave); String encriptado = encriptador.encrypt(mensaje); Operaciones.insertarFirma(clave, encriptado, conexion); conexion.terminaConexion(); out.print(clave); out.close(); } }



Página 148

D.13 Código para el algoritmo DSA.

package com.r2.mx.kajoolqr.web.encriptacion; import java.io.UnsupportedEncodingException; import java.security.InvalidKeyException; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.NoSuchAlgorithmException; import java.security.PrivateKey; import java.security.PublicKey; import java.security.SecureRandom; import java.security.Signature; import java.security.SignatureException; import java.security.interfaces.DSAPrivateKey; import java.security.interfaces.DSAPublicKey; import java.security.spec.InvalidKeySpecException; import java.security.spec.PKCS8EncodedKeySpec; import java.security.spec.X509EncodedKeySpec; public class DSA { public final static KeyPair generaLlaves()throws ExcepcionDSA{ try{ KeyPairGenerator generador = KeyPairGenerator.getInstance("DSA"); SecureRandom seguridad = new SecureRandom(); generador.initialize(1024, seguridad); KeyPair llaves = generador.generateKeyPair(); return llaves; }catch(NoSuchAlgorithmException e){ throw new ExcepcionDSA("\n\nMétodo - generaLlaves\nExcepcion NoSuchAlgorithm: "+e.getMessage()); } } public final static byte[] firmaMensaje(String mensaje, byte[] llavePrivada)throws ExcepcionDSA{ try{ Signature firmador = Signature.getInstance("DSA"); KeyFactory fabrica = KeyFactory.getInstance("DSA"); PKCS8EncodedKeySpec llaveCodificada = new PKCS8EncodedKeySpec(llavePrivada); DSAPrivateKey llavePrivadaDSA = (DSAPrivateKey) fabrica.generatePrivate(llaveCodificada); firmador.initSign(llavePrivadaDSA);



Página 149

firmador.update(mensaje.getBytes("UTF-8")); return(firmador.sign()); } catch (NoSuchAlgorithmException e){ throw new ExcepcionDSA("\n\nMétodo - firmaMensaje\nExcepcion NoSuchAlgorithm: "+e.getMessage()); } catch (InvalidKeyException e){ throw new ExcepcionDSA("\n\nMétodo - firmaMensaje\nExcepcion InvalidKey: "+e.getMessage()); } catch (InvalidKeySpecException e) { throw new ExcepcionDSA("\n\nMétodo - firmaMensaje\nExcepcion InvalidKeySpec: "+e.getMessage()); } catch (SignatureException e){ throw new ExcepcionDSA("\n\nMétodo - firmaMensaje\nExcepcion Signature: "+e.getMessage()); } catch (UnsupportedEncodingException e){ throw new ExcepcionDSA("\n\nMétodo - verificaFirma\nExcepcion UnsupportedEncoding: "+e.getMessage()); } } public final static boolean verificaFirma(String mensaje, byte[] firma, byte[] llavePublica)throws ExcepcionDSA{ try{ Signature verificador = Signature.getInstance("DSA"); KeyFactory fabrica = KeyFactory.getInstance("DSA"); X509EncodedKeySpec llaveCodificada = new X509EncodedKeySpec(llavePublica); DSAPublicKey llavePublicaDSA = (DSAPublicKey) fabrica.generatePublic(llaveCodificada); verificador.initVerify(llavePublicaDSA); verificador.update(mensaje.getBytes("UTF-8")); return (verificador.verify(firma)); } catch (NoSuchAlgorithmException e){ throw new ExcepcionDSA("\n\nMétodo - verificaFirma\nExcepcion NoSuchAlgorithm: "+e.getMessage()); } catch (InvalidKeyException e){ throw new ExcepcionDSA("\n\nMétodo - verificaFirma\nExcepcion InvalidKey: "+e.getMessage()); } catch (InvalidKeySpecException e) { throw new ExcepcionDSA("\n\nMétodo - firmaMensaje\nExcepcion InvalidKeySpec: "+e.getMessage()); } catch (SignatureException e){ throw new ExcepcionDSA("\n\nMétodo - verificaFirma\nExcepcion Signature: "+e.getMessage()); } catch (UnsupportedEncodingException e){



Página 150

throw new ExcepcionDSA("\n\nMétodo - verificaFirma\nExcepcion UnsupportedEncoding: "+e.getMessage()); } } }



Página 151

Referencias

I. Romaní, C. C.; Kuklinski, H. P., Planeta Web 2.0. Inteligencia colectiva o

medios fast food, E-book gratuito, México, 2007. http://www.planetaweb2.net/

accedido en 10/05/2012

II. Cárdenas, E. R., Manual de Derecho de Comercio Electrónico y de Internet,

Centro Editorial de Universidad del Rosario, Colombia, 2006

III. Gomes Sikansi, F. E., et. al., Digital Signature for Mobile Devices: A New

Implementation and Evaluation, Revista “International Journal of Future

Generation Communication and Networking”, Vol. 4, No. 2, Junio, 2011,

pág. 23 – 36.

IV. Flores C., Juan J., Método para la solución de problemas utilizando la

programación orientada a objetos, Editorial Universidad de San Martin de

Porres, 2011, pág. 18-27.

V. Castro Letchtaler, A. R., Teleinformática para Ingenieros en Sistemas de

Información, Editorial Reverté, España, 2° Edición, 1999, pág. 274.

VI. Folleto electrónico del Instituto Nacional de Tecnología de la Información -

http://www.iti.gov.br/twiki/pub/Certificacao/CartilhasCd/brochura01.pdf -

accedido el 16/05/2012.

VII. Silberschatz, A.; et. al. , Sistemas operacionais com Java, Elsevier Editora

Ltda., traducción del original Operating System Concepts with Java, 2008,

pág. 436.

VIII. Stallings, William, Fundamentos de seguridad en redes: aplicaciones y

estándares, PEARSON Educación, España, 2° Edición, 2004, pág. 67

IX. Tanenbaum, A. S.; Redes de computadoras, PEARSON Educación,

México, 2003, pág. 761, 762

X. http://www.denso-wave.com/qrcode/qrfeature-e.html - sitio oficial del

proyecto QR Code accedido el 04/02/2012

XI. Martínez Gil, F. A., Martín Quetglás, G., Introducción a la programación

estructurada en C, Editorial Maite Simon, España, 2003, pág. 45 – 51.

XII. Salas Campos, Ileana, Una propuesta didáctica para la programación con

MicroMundos, Editorial Universidad Estatal a Distancia, 1° Edición, Costa

Rica, 2006, pág. 73 – 75

XIII. Berlanga Llavori, Rafael, et. al., Introducción a la programación con

PASCAL, Publicaciones de la Universidad Jaume, Francia, 2000, pág. 49.

XIV. Llanos Ferraris, Diego, Fundamentos de Informática y Programación en C,

Editorial Paraninfo S.A., España, 1° Edición, 2010, pág. 73 – 74.



Página 152

XV. Cerezo, Y., et.al., Iniciación a la programación en C#: Un enfoque práctico,

Publicaciones Universitarias, 2007, pág. 2

XVI. Burnette, Ed, Eclipse IDE: guía de bolso, Ed. Bookman, 2006, pág 11.

XVII. Boudreau T., et. al., NetBeans: The Definitive Guide, O‟Reilly & Associates,

Inc., 2003, pág. XIII y XIV.

XVIII. Date, C. J., Introducción a los sistemas de bases de datos. El modelo

relacional, PEARSON Educación, 7° Edición, México, 2001, pág. 6 – 7.

XIX. http://www.gnu.org/licenses/quick-guide-gplv3.html - sitio web oficial del

proyecto GNU GLP accedido el 30/08/2012.

XX. http://www.postgresql.org.es/ - sitio web oficial del proyecto PostgreSQL

accedido el 30/08/2012.

XXI. http://www.mysql.com/ - sitio web oficial del proyecto MySQL accedido el

28/08/2012.

XXII. http://www.microsoft.com/es-es/sqlserver/default.aspx - sitio web oficial del

producto Microsoft SQL Server accedido el 28/08/2012.

XXIII. Peter, Rob, et. al., Sistemas de bases de datos. Diseño, implementación y

administración, Thomsom Editores, México, 2002, pág. 574-576.

XXIV. Laudon, K. C., Laudon, J. P., Sistemas de Información Gerencial,

PEARSON Educación, 8° Edición, México, 2004, pág. 296.

XXV. Morera, Juan, Conceptos de sistemas operativos, Universidad Pontificia

Comillas, España, 2002, pág. 159-160.

XXVI. Stair, R. M., Principios de sistemas de información. Enfoque administrativo,

THOMSON Editores, 4° Edición, México, 2000, pág. 266

XXVII. Jamrich Parsons, June, Conceptos de computación. Nuevas perspectivas,

CENGAGE Learning, México, 10° Edición, 2008, pág. 257- 259

XXVIII. Carballar, José Antonio, Wi-Fi. Lo que se necesita conocer, RC Libros,

España, 2010, pág. 1-2.

XXIX. http://jelastic.com/ - sitio web oficial de la plataforma huésped de Java.

instituto politÉcnico...

Documents