“Arquitectura Estándar para Identificación...

Directores:

M. en C. Chadwick Carreto Arellano M. en C. Héctor Becerril Mendoza

INSTITUTO POLITÉCNICO NACIONAL

ESCUELA SUPERIOR DE INGENIERIA MECANICA Y ELECTRICA

E S I M E

“Arquitectura Estándar para Identificación Digital”

T E S I S

QUE PARA OBTENER EL TÍTULO DE: INGENIERO EN COMUNICACIONES Y ELECTRONICA P R E S E N T A N :

México, D.F. a 12 de Mayo de 2010

CASTRO SANDOVAL JUAN DIEGOMIRELES GONZALEZ MARITZA . PASTRANA ZEPEDA GUADALUPE

AGRADECIMIENTOS

El trabajo que aquí se presenta, es el resultado sinérgico de esfuerzos individuales, institucionales y comunitarios. Una página no alcanzaría para citar a todos los que directa o indirectamente contribuyeron para obtener los resultados que a continuación se presentan, sin embargo, y corriendo el riesgo de caer en odiosas omisiones, se referencia a continuación a los pilares de esta investigación. Quiero agradecer a toda mi familia, es especial a mis padres por el apoyo incondicional que siempre me han brindado en todos los proyectos y demás metas que me he trazado en la vida, de los cuales siempre he tenido su mano protectora y su voz de aliento y respaldo. Ellos me han brindado las fuerzas y los medios suficientes para poder desarrollarme intelectual y moralmente, sus consejos siempre oportunos y en el momento indicado, muchas gracias los quiero muchísimo.

Juan Diego Castro Sandoval. Quiero agradecer a Dios y a mi familia por estar a mi lado, a mi abuelita y hermanos por su esfuerzo y los sacrificios realizados para poder apoyarme en mis estudios, y poder lograr este objetivo de mi vida , especialmente a mi mamá por estar siempre al pendiente de mi, gracias por su compañía en los buenos y malos momentos por ser madre y padre .

Guadalupe Pastrana Zepeda Un sueño hecho realidad: “Nada es imposible”, todos los días me lo repetía, había ocasiones que estuve a punto de rendirme, pero ¿qué creen? Cuando pensaba eso… llegan a mi mente mis más grandes motivos: MI FAMILIA: mi mamita hermosa, Javier, mi hermanito Gabriel, Lalita y mi Bomby. Quiero dedicarles con mucho orgullo esta TESIS, porque es la culminación de un proyecto que inicié con ustedes y para ustedes, siempre recuerden que son mi más grande inspiración y les agradezco que siempre hayan estado conmigo. LOS AMO con todo mi corazón…. Ah!!!! Se me estaba olvidando, mis peques, Vale hermosa, mi Bibis chiquitita y no podemos omitir a la bebesita que viene en camino, también “esto” va con todo mi cariño y mi amor. Gracias a todos ustedes, los amo. ¡Miguel! Mi amor, gracias por siempre apoyarme y por siempre estar ahí para mí. TE AMO.

Mireles González Maritza

INDICE

INTRODUCCIÓN....................................................................................................................... 1 Objetivo ....................................................................................................................................... 2 Estado del Arte ............................................................................................................................ 3 Soluciones existentes................................................................................................................... 4 CAPITULO I ANTECEDENTES............................................................................................... 5 1. ANTECEDENTES.................................................................................................................. 6 1.1 Firma Electrónica .................................................................................................................. 6 1.2 Firma Digital, IMSS .............................................................................................................. 7 1.3 Certificación Operativa ......................................................................................................... 7 1.4 E-Passport............................................................................................................................ 11 1.5 DNI Digital......................................................................................................................... 13 1.6 Firma Electrónica, Kalysis ................................................................................................. 15 1.7 Criptografía ........................................................................................................................ 15 1.7.1 Criptografía simétrica - Criptografía de clave secreta...................................................... 16 1.7.2 Criptografía asimétrica ..................................................................................................... 18 1.8 Certificados de Seguridad Electrónicos ............................................................................. 21 1.9 PKI....................................................................................................................................... 24 CAPITULO II ARQUITECTURA ........................................................................................... 27 3. ARQUITECTURA................................................................................................................ 28 CAPITULO III DESARROLLO DE LA PROPUESTA .......................................................... 31 3. IMPLEMENTACION .......................................................................................................... 32 3.1 Módulo de Certificación de Usuarios y Firma de Documentos .......................................... 32 3.1.1 Los certificados ................................................................................................................ 33 3.1.2 Las Firmas ........................................................................................................................ 33 3.1.3 Las Llaves......................................................................................................................... 35 3.1.4 Las interfaces................................................................................................................... 36 3.1.5 Navegación....................................................................................................................... 37 3.2 Módulo de Validación e Interpretación de la Identificación Digital................................... 38 3.2.1 Funcionamiento del modulo............................................................................................. 39 3.2.2 Funciones del modulo ...................................................................................................... 40 3.2.2.1 Validación de autenticidad de certificado de usuario.................................................... 40 3.2.2.2 Validación de fecha de expiración del certificado. ....................................................... 40 3.2.2.3 Validación de revocación de certificado. ...................................................................... 41 3.2.2.4 Interpretación de la identificación. ................................................................................ 42 3.3 Módulo de Servicios de Certificación .............................................................................. 45 3.3.1 Revocación de Certificados.............................................................................................. 45 3.3.2 El Servidor........................................................................................................................ 48 CONCLUSIONES..................................................................................................................... 54 BIBLIOGRAFÍA....................................................................................................................... 56 GLOSARIO............................................................................................................................... 57 ANEXOS................................................................................................................................... 61 ANEXO 1. CÓDIGO MÓDULO DE CERTIFICACIÓN ........................................................ 62 ANEXO 2. CÓDIGO MÓDULO DE VERIFICACION E INTERPRETACION.................... 92 ANEXO 3. CÓDIGO MÓDULO DE SERVICIOS................................................................ 111

INDICE DE FIGURAS

Figura 1.1 Firma Electrónica ...................................................................................................... 9 Figura 1.2 Verificación de documento ectrónico ..................................................................... 10 Figura 1.1 E-passsport ............................................................................................................... 11 Figura 1.4 Nueva imagen, E-Passport ....................................................................................... 12 Figura 1.2 Logotipo................................................................................................................... 12 Figura 1.3 DNI Electrónico ....................................................................................................... 14 Figura 1.4 Criptografía simétrica .............................................................................................. 16 Figura 1.5 Criptografía asimétrica............................................................................................. 18 Figura 1.6 Algoritmo MD5 ....................................................................................................... 20 Figura 1.10 Componentes de una PKI....................................................................................... 25 Figura 7 Ejemplo grafico de la Identificación Digital generada por la arquitectura AEspID...................................................................................................................................... 29 Figura 8 Modulos de Certificación............................................................................................ 30 Figura 3.1Interfaz Utilidades..................................................................................................... 36 Figura 32 Interfaz Principal....................................................................................................... 36 Figura 3.3Interfaz Alta .............................................................................................................. 36 Figura 3.4Interfaz Firmar .......................................................................................................... 36 Figura 3.5Interfaz Agregar ........................................................................................................ 36 Figura 3.6 Navegación del módulo de certificación.................................................................. 37 Figura 3.7 Licencia del Visor de Acrobat ................................................................................. 39 Figura 3.8 Certificado no válido................................................................................................ 40 Figura 3.9 Certificado Expirado................................................................................................ 41 Figura 3.10 Certificado Revocado............................................................................................. 41 Figura 9 Identificación Correcta................................................................................................ 42 Figura 3.12 Documento válido.................................................................................................. 43 Figura 3.13 Documento no válido............................................................................................. 44 Figura 3.14 Documento no firmado .......................................................................................... 44 Figura 3.15 Página Principal de los servicios de Certificación................................................. 45 Figura 3.16 Página de Información ........................................................................................... 46 Figura 3.17 Página de revocación de certificados..................................................................... 47 Figura 3.18 Usuario no encontrado ........................................................................................... 47 Figura 10 Contraseña incorrecta................................................................................................ 48

INDICE DE TABLAS Tabla 1. Ejemplo de Identificación ……………………………………………………….32

Tabla 2. Ejemplo de identificación real……………………………………………………34

Tabla 3. Interpretación del certificado de la AC en el Sistema…………………………….35

Arquitectura Estándar para Identificación Digital

1

INTRODUCCIÓN Dentro de cualquier sociedad humana, ya sea una comunidad laboral, de educación, o de cualquier índole, la identidad de cada uno de sus integrantes es muy importante, puesto que le permitirá aplicar las leyes y beneficios comunes establecidos en cada sociedad. Sabiendo que la identificación de personas es y será un tema de investigación y desarrollo importante ligado a la constante evolución de las sociedades humanas, y aunque la identidad siempre es física, es necesario establecer mecanismos y procedimientos electrónicos para verificarla en estos nuevos ámbitos. Otorgar identidad personal a los ciudadanos adquiere una nueva dimensión cuando se trata de establecerla para un uso no presencial en medios telemáticos. La identidad personal es un concepto importante que toma aún más valor en la actual Sociedad, basada en las tecnologías de la información. Ya que en las redes informáticas de entornos corporativos, educativos o sociales, viajan miles de millones de objetos que no son lo que dicen o aparentan ser. Una página de Internet (WEB), por ejemplo, puede ser suplantada por otra para capturar datos personales, cuentas bancarias, correos, etcétera. En esa frontera de incertidumbre los sistemas de Identidad Digital ofrecen confianza y seguridad.


2

Objetivo El desarrollo e investigación del presente trabajo está basado en construir e implementar un sistema de identificación de personas utilizando dispositivos informáticos, de almacenamiento portátil, certificación de usuarios y documentos electrónicos con firma digital; capaz de ser implementado fácilmente sin afectar el funcionamiento de sistemas de información ya existentes. Así mismo, que el sistema creado, tenga la característica de conectarse a través de Internet con una autoridad central para verificar la validez de la identificación en el momento de ser usada, además de brindar una interfaz de usuario sencilla y práctica para la interpretación de la identificación digital.


3

Estado del Arte Considerando la importancia de la identidad en la sociedades humanas, entendemos también la necesidad de contar con medios de control que brinden los acceso a recursos o instalaciones, derechos, obligaciones, etcétera. Cuando se busca suplir esta necesidad de medios de control, se suele recurrir a la creación de identificaciones propias a través de empresas dedicadas a esa tarea, o con la propia impresión de micas con ciertos elementos de seguridad. Ejemplos:

• El proceso de identificación personal en nuestro país (México), se reduce al uso de

una serie de credenciales y documentos, de entre los que la credencial de elector

(expedida por el Instituto Federal Electoral) por ser la más práctica, es la más usada.

Esta credencial es indispensable en casi cualquier trámite en la que se necesite

verificar la identidad de la persona, desde una operación bancaria, hasta el trámite de

un pasaporte. Esta credencial es expedida por la institución encargada de gestionar el

proceso electoral, y que por ende la información contenida en ella es la mínima

requerida para dicho proceso.

• Las credenciales expedidas por escuelas para sus estudiantes o docentes, te permiten

entrar a sus instalaciones, comprobar que estas inscrito o trabajando en ellas, etc.

• Las credenciales expedidas por empresas (fuera del área de la educación), que portan

sus trabajadores, y que según el tipo de las mismas dan privilegios diferentes a sus

portadores, etc.

Por lo anterior, podemos decir que esta necesidad se ha resuelto en cierta medida por medio de los sistemas de identificación existentes. La problemática, entonces, como se expresa en la introducción, no es el simple hecho de la identificación, sino la posibilidad de extender sus capacidades y hacer uso de los avances tecnológicos actuales, esto bajo una buena propuesta de arquitectura.


4

Si analizamos nuevamente las identificaciones bajo esta problemática, podemos decir, que es posible mejorar sus capacidades, en cantidad de información, portabilidad, seguridad y generalización. Dicho de otra manera, podemos tener una identificación que contenga información completa, fácil de portar, más segura y que permita identificarte en múltiples organizaciones. El proyecto se enfocará a una modalidad de desarrollo de sistemas, debido a que se pretende desarrollar una arquitectura estándar para identificación digital, la cual nos permitirá, portar dicha identificación digital en diversos equipos, lo que se traduce en una mayor portabilidad de la información personal certificada. Soluciones existentes Las tecnologías de solución para la Identidad Digital suelen sustentarse en arquitecturas PKI (por sus siglas en inglés: Public Key Infrastructure) en la que se utilizan dispositivos criptográficos para almacenar y generar claves de forma segura (HSM, Tarjetas criptográficas, Token USB). En determinados sistemas puede resultar más útil para una organización decidirse por otras arquitecturas que, en ocasiones, pueden convertirse en complementarias como: contraseñas dinámicas (One Time Password), dispositivos biométricos, tarjetas inteligentes (Smart Card).

5

CAPITULO I ANTECEDENTES

Arquitectura Estándar para Identificación Digital Capítulo I Antecedentes

6

1. ANTECEDENTES 1.1 Firma Electrónica

El objetivo básico de la firma electrónica es aportar al mundo de los documentos electrónicos la misma funcionalidad que aporta la firma manuscrita a un documento impreso, es decir, identificar al autor del mismo y, en el caso de documentos compartidos entre diferentes entidades o personas, fijar el contenido del documento mediante el cruce de copias firmadas por todas las partes implicadas. A diferencia de las prácticas que nos son habituales en el mundo físico, como por ejemplo, concertar una reunión para firmar las copias, la firma electrónica debe, además, satisfacer la necesidad de firmar un documento por parte de personas que pueden encontrarse a miles de kilómetros y que realizarán la firma sin coincidir en el tiempo. Los retos que debe atender la firma electrónica son garantizar la identidad del firmante y garantizar que el documento no ha sido modificado tras ser firmado. El concepto de identidad debe ser complementado con el de “no repudio” que describiremos con detalle más adelante. Para garantizar la identidad del firmante se emplea la tecnología de par de claves vinculada a los datos identificativos del titular del certificado. De este modo, cuando se firma un documento, se emplea un número único que sólo pertenece al firmante. El receptor del documento verifica la firma con la parte pública de la clave, de este modo, si el proceso de validación es positivo, debe concluirse que el firmante del documento es el titular del certificado. La integridad del documento no se refiere al hecho de validar el contenido, sino de garantizar que el documento no ha sido modificado tras su firma. Para garantizar esto no es necesario que un tercero custodie una copia del documento, sino que se realiza generando un código único del documento a partir de su estructura interna en el momento de ser firmado. Cualquier alteración del contenido del documento provocará, que al aplicar de nuevo la función de generación de código único, sea imposible reproducir el original, por tanto, quedará rota la integridad del contenido.


7

1.2 Firma Digital, IMSS El Instituto Mexicano del Seguro Social (IMSS), una institución grande e importante de México, ofrece como parte de los programas de modernización y simplificación administrativa el mecanismo de firma digital, como una opción segura y confiable para el intercambio de información que realicen las empresas con el Instituto. Con el proceso de Certificación Digital, cada registro patronal podrá obtener su Número Patronal de Identificación Electrónica y un certificado digital para acceder a las aplicaciones en Internet del IMSS. Con su certificado digital y Número Patronal de Identificación Electrónica se podrá enviar información al IMSS con las ventajas que la firma digital provee. 1.3 Certificación Operativa La certificación operativa es una medida de seguridad que permite a un registro patronal con Certificado Digital vigente, autorizar la generación de un Certificado Digital para cada persona interna a la empresa que se le considere para utilizar los sistemas del IMSS. Cada registro patronal desde Internet podrá solicitar y cancelar los Certificados Digitales de cada una de las personas que asigne como usuarios en los sistemas en Internet del IMSS. Con la certificación operativa se obtienen muchos beneficios:

• La empresa no tiene la necesidad de difundir la contraseña de un Certificado Digital y perder el control de las acciones realizadas por cada persona en su empresa.

• Evita que la fluctuación de personal interno a la empresa pueda poner en riesgo la información que se intercambia con el IMSS desde el momento en que se utilice un solo Certificado Digital para cada persona asignada.

• Se tiene mayor flexibilidad, ya que en cualquier momento la empresa puede solicitar o cancelar Certificados Operativos desde Internet.


8

Firma Electrónica Avanzada (FIEL.- SAT/SHCP)

La Firma Electrónica Avanzada "Fiel" es un conjunto de datos que se adjuntan a un mensaje electrónico, cuyo propósito es identificar al emisor del mensaje como autor legítimo de éste, tal y como si se tratara de una firma autógrafa. Por sus características, la Fiel brinda seguridad a las transacciones electrónicas de los contribuyentes, con su uso se puede identificar al autor del mensaje y verificar que no haya sido modificado. Su diseño se basa en estándares internacionales de infraestructura de claves públicas o PKI en donde se utilizan dos claves o llaves para el envío de mensajes:

• La "llave o clave privada" que únicamente es conocida por el titular de la Fiel, que sirve para cifrar datos; y

• La "llave o clave pública", disponible en Internet para consulta de todos los usuarios

de servicios electrónicos, con la que se descifran datos. En términos computacionales es imposible descifrar un mensaje utilizando una llave que no corresponda.

Cualidades de un documento firmado de manera electrónica Por sus características la Fiel tiene las siguientes cualidades:

• Es única por documento y signatario. • Es posible identificar al autor. • Es infalsificable. • Es imposible de transferir a otro documento.

Adicionalmente, un mensaje firmado electrónicamente tiene las siguientes características:

• Integridad, se puede detectar si el mensaje original fue modificado. • No repudio, el autor del mensaje no puede decir que no lo hizo. • Autenticidad, el emisor del mensaje queda acreditado, y su “firma electrónica”

tendrá la misma validez que una firma autógrafa. • Confidencialidad, es decir, sólo el receptor puede descifrar la información contenida.


9

Firma de documentos electrónicos Para la firma de documentos electrónicos se necesita:

• Una clave o llave privada (archivo electrónico con extensión .KEY) y su respectiva contraseña de acceso.

• Un certificado digital (archivo electrónico con extensión .CER) expedido por el SAT, que contiene la clave o llave pública del titular de la Fiel.

Procedimiento:

• El primer paso para firmar documentos electrónicos consiste en aplicar una “función resumen” al documento que se desea enviar. Esta función convierte un archivo electrónico de cualquier tamaño en pequeño texto cifrado (que recibe el nombre de "resumen"), a los resúmenes se les conoce como las "huellas digitales" de los archivos electrónicos y la probabilidad de tener dos resúmenes iguales para dos documentos distintos es casi nula.

• Una vez obtenido el resumen del documento, éste es cifrado utilizando la llave privada del emisor del mensaje (archivo electrónico con extensión .KEY). El resultado es lo que se denomina “firma electrónica”, misma que se anexa al mensaje original, como lo indica la Figura 1.1.

Figura 1.1 Firma Electrónica


10

Verificación un documento electrónico El receptor del mensaje debe descifrar el contenido de la "firma electrónica" utilizando la clave pública contenida en el certificado digital del emisor (archivo electrónico con extensión .CER), al descifrar el contenido de la "firma electrónica" se obtiene el resumen del documento original enviado por el emisor. Los certificados digitales se encuentran disponibles en Internet para consulta de todos los usuarios de los servicios electrónicos. Procedimiento

• El receptor del mensaje debe aplicar la función "resumen" al documento electrónico recibido.

• Al comparar resúmenes (el del documento recibido y el de la “firma electrónica”), el receptor podrá:

1. Validar que el documento recibido no sufrió alteraciones (ya que los resúmenes son idénticos), y

2. Comprobar la autoría del mensaje, ya que para descifrar la “firma electrónica” del mensaje, el receptor utilizó el certificado digital que el SAT expidió al emisor.

Se puede visualizar este procedimiento en la Figura.- 1.2

Figura 1.2 Verificación de documento electrónico


11

Las dependencias del gobierno federal y órganos desconcentrados que utilizan firmas electrónicas para la presentación de trámites de manera remota son:

• Banco de México • Secretaría de la Función Pública • Secretaría de Economía • Instituto Mexicano del Seguro Social

En otros países Las Administraciones Tributarias afiliadas al “Subgrupo de Servicios Electrónicos” de la Organización para la Cooperación del Desarrollo Económico (OCDE), que actualmente hacen uso de firmas electrónicas para la presentación de declaraciones y trámites diversos son:

1.4 E-Passport Los nuevos pasaportes electrónicos de los Estados Unidos de Norte América. Las visas para ciudadanos de México y el nuevo pasaporte electrónico estadounidense o “E-Passport” contienen la misma información que el pasaporte ordinario pero con la adición de un microchip insertado en la parte posterior del mismo. El microchip almacena de manera segura la misma información impresa que está en la página donde está la fotografía, pero adicionalmente incluye una fotografía digital. (Figura 1.3)

Figura 1.3 E-Passport.

Corea

España

Finlandia

Hungría

Italia

Dinamarca Estados Unidos

Francia Irlanda

Japón

Eslovaquia

Finlandia

Holanda

Islandia

Suecia

http://www.banxico.org.mx/sistemasdepago/ies/ies_entrada.html

http://www.declaranet.gob.mx/

http://www.sat.gob.mx/sitio_internet/e_sat/tu_firma/60_6695.html

http://idse.imss.gob.mx/imss/


12

La adición de esta fotografía permite efectuar comparaciones biométricas por medio del uso de tecnología de reconocimiento facial en las fronteras internacionales. El E-Passport también tiene una nueva imagen, incorporando características adicionales de seguridad y anti fraude, un número único de identificación y una firma digital para proteger la información almacenada. (Figura 1.4)

Figura 1.4 Nueva imagen, E-Passport.

El nuevo pasaporte electrónico de los Estados Unidos, utiliza la imagen digital almacenada como identificador biométrico para el reconocimiento facial del portador del pasaporte. El pasaporte electrónico facilita el viajar debido a que proporciona un sistema de identificación automatizado, se realizan más rápido las inspecciones de inmigración y proporciona mayor seguridad y protección a las fronteras. El nuevo pasaporte electrónico lleva un logo que es un símbolo internacional para los pasaportes electrónicos, como se puede visualizar en la Figura 1.5, significa que el pasaporte contiene un circuito electrónico o microchip en donde se almacena electrónicamente la identidad del portador. Este logotipo estará en las líneas de inspecciones de las fronteras, en todos los aeropuertos y puertos de entrada equipados con lectores de datos especiales para estos pasaportes electrónicos.

Figura 1.5 Logotipo


13

Los datos del nuevo pasaporte electrónico sólo podrán ser leídos de cerca y con el pasaporte abierto, ya que este tiene implementado un sistema de seguridad para evitar que los datos sean leídos si el pasaporte está cerrado. Adicionalmente, contiene características de seguridad que impiden que la información sea alterada o inclusive leída, ya que contiene información encriptada. Si por algún motivo el chip se llegará a dañar, el pasaporte seguirá siendo válido hasta su fecha de caducidad. Todos los pasaportes emitidos con anterioridad serán validos hasta su fecha de caducidad. 1.5 DNI (Documento Nacional de Identidad) El DNI (Documento Nacional de Identidad) electrónico es el documento que acredita, desde hace 50 años la identidad, los datos personales y la nacionalidad española de su titular. Con el paso de los años el DNI ha ido evolucionando e incorporando las innovaciones tecnológicas disponible en cada momento, con el objetivo de aumentar la seguridad del documento. Con el uso de Internet se hace necesario incorporar los mecanismos adecuados para identificar a las personas, y es importante poder utilizar en el mundo virtual las mismas herramientas que utilizamos día a día en el mundo físico. Como son las acreditaciones electrónicas, la firma digital para documentos electrónicos. De ese modo le damos una validez jurídica equivalente a la que les proporciona la firma manuscrita. La única novedad del DNI es la incorporación de un pequeño circuito integrado (chip) capaz de guardar de forma segura información y de procesarla internamente. Para poder introducir el chip cambiamos la cartulina plastificada por una tarjeta de material plástico, que proporciona más seguridad, esta descripción puede ser visualizada en la Figura 1.6 DNI. La utilidad del nuevo DNI electrónico:

• Para hacer compras firmadas a través de Internet.

• Para hacer trámites completos en la Administración pública.

• Para hacer tramites bancarios.

• Como tarjeta identificativa en el trabajo.

• Para trabajar con nuestro ordenador de forma segura.

• Para identificar a las personas con las que nos comunicamos por internet.

http://es.wikipedia.org/wiki/DNI#Espa.C3.B1a



14

Figura 1.6 DNI Electrónico

Para utilizar el DNI electrónico será necesario elementos hardware y software que nos van a permitir el acceso al chip de la tarjeta y la utilización de los certificados contenidos en él. Los elementos hardware serán:

• Un ordenador personal. • Un lector de tarjetas inteligentes que cumpla el estándar ISO 7816, puede estar

incluido en el teclado, conectado por vía USB o a través de una interfaz CMCIA. Los elementos software:

• Sistemas operativos (Windows, Linux, Unix, Mac). • Navegadores (Internet Explorer, Mozilla Firefox, Netscape versión 4.78 o superior). • Controladores / Módulos criptográficos. Estos softwares se podrán obtener en el área

de descarga que proporciona la página del ministerio del interior (http://www.dnielectronico.es/descargas).

• La versión JAVA 2.5 o superior.


15

1.6 Firma Electrónica, Kalysis Kalysiso ofrece una solución de firma electrónica que es segura, móvil, y fácil de implementar para el usuario final – firma centralizada con máxima autenticación. Esta solución reside en el servidor centralizado que contiene en un entorno de alta seguridad las claves de las firmas del usuario. Esto permite a los usuarios realizar transacciones seguras y firmarlas desde cualquier PC (Personal Computer) estándar equipado con un navegador Web o un cliente de correo. La clave de la firma no es exportada en ningún momento y está siempre bajo el control de su propietario que puede acceder a través del sistema de autenticación. El desarrollo de la solución no requiere instalar ningún periférico o software en el ordenador del cliente. El servidor ofrece protección óptima de claves lógica y física, que permite un uso muy fácil del servicio desde cualquier periférico conectado a redes de comunicaciones. Esta solución de Kalysis se basa en un lector portátil de tarjetas inteligentes. El sistema genera claves dinámicas, o firmas, desde las funciones criptográficas de la tarjeta inteligente. Estas claves son válidas sólo una vez, y se usan para autenticar al propietario, así como para permitirle el acceso a un entorno completamente protegido al servidor de la Plataforma de firma para usar su clave de firma electrónica. El sistema funciona con tarjetas inteligentes existentes y ya emitidas o tarjetas privadas. Esta aplicación está dedicada a transacciones de Banca a Negocios, de Negocios entre Negocios (B2B), y de Negocios a Cliente (B2C). 1.7 Criptografía La aplicación principal de los algoritmos de cifrado es garantizar la confidencialidad de los documentos, aunque estos resultasen accesibles a personas no autorizadas. La situación práctica en la que más se utiliza, es la transferencia de información por canales de comunicación no seguros, como es Internet. Criptografía es la técnica de transformar un mensaje inteligible, denominado texto en claro, en otro que sólo puedan entender las personas autorizadas a ello, que llamaremos criptograma o texto cifrado. El método o sistema empleado para encriptar el texto en claro se denomina algoritmo de encriptación o algoritmo criptográfico. La posibilidad de manejar distintos estándares criptográficos depende de que la mayoría de los protocolos de seguridad modernos y aplicaciones de seguridad que sean definidas independientes de los algoritmos, es decir, permitan seleccionar de un conjunto de algoritmos criptográficos para la misma función de seguridad entre las diversas medidas de seguridad.


16

Los algoritmos de cifrado juegan un papel decisivo en la transferencia de archivos, por ejemplo: por correo electrónico, en la transferencia de información mediante navegadores, durante el acceso a la página Web de un banco. También se utilizan las técnicas de cifrado para proteger documentos importantes dentro del disco duro o en cualquier medio de almacenamiento digital por si se produce un acceso ilegal. Un acceso no autorizado a información confidencial, puede tener lugar tanto por un acceso ilícito al sistema; como por el robo de los medios físicos de almacenamiento (especialmente en ordenadores portátiles o flash drive). Existen dos tipos de criptografía básica: la criptografía simétrica, donde existe una clave secreta que se utiliza para cifrar y descifrar; y la asimétrica, donde existe una clave pública y otra privada. Cada una de ellas contiene sus propios algoritmos de cifrado criptográfico. 1.7.1 Criptografía simétrica - Criptografía de clave secreta La simetría se refiere a que las partes tienen la misma llave tanto para cifrar como para descifrar, es decir, este método criptográfico utiliza una misma clave para cifrar y para descifrar mensajes. Las dos partes que se comunican han de ponerse de acuerdo de antemano sobre la clave a usar. Una vez que ambas tienen acceso a esta clave, el remitente cifra un mensaje usándola, lo envía al destinatario, y éste lo descifra con la misma. (Figura 1.7)

Figura 1.7 Criptografía simétrica

http://es.wikipedia.org/wiki/Criptograf%C3%ADa


17

La criptografía simétrica ha sido la más usada en toda la historia, ésta ha podido ser implementada en diferentes dispositivos, manuales, mecánicos, eléctricos, hasta los algoritmos actuales que son programables en cualquier computadora. La idea general es aplicar diferentes funciones al mensaje que se quiere cifrar, de tal modo que sólo conociendo una clave pueda aplicarse de forma inversa para poder así descifrar. Este tipo de criptografía se conoce también como criptografía de clave privada o criptografía de llave privada Características

• Misma clave para cifrado y descifrado. • Muy rápidos, adecuados para cifrar grandes volúmenes de datos.

Algoritmos de Flujo: De flujo (stream): RC2, RC4, CAST. Existen diversos algoritmos de cifrado de bloques de llave única, entre ellos tenemos:

• Triple-DES: o DES es aplicado tres veces, con secuencias de cifrado y descifrado, combinando la utilización de dos llaves.

• Lucifer: precursor del DES. • Madryga: trabaja con 8 bits, usando or-exclusivo y deslocamiento de bits. • NewDES: bloques de 64 bits y llave de 120 bits. • FEAL-N: basado en DES, se puede especificar el número de pasos del cifrado. Se

utiliza menos de ocho pasos. • REDOC II y III: realizan operaciones sobre bytes. • LOKI: bloque y llave de 64 bits. • IDEA, RC5, Blowfish. • Khufu y Khafre: trabajan de forma semejante a DES, usan tablas de sustitución de

256 posiciones de 32 bits, contra las seis posiciones de 4 bits de DES. Usan llaves de 512 bits y un número de pasos flexibles, múltiplo de 8.

• IDEA: bloques de 64 bits con llave de 128 bits. • MMB: bloques y llave de 128 bits. • Skipjack: llave de 80 bits y treinta y dos pasos de procesamiento.


18

1.7.2 Criptografía asimétrica La criptografía asimétrica, es por definición, aquella que utiliza dos claves diferentes para cada usuario, una para cifrar que se le llama clave pública y otra para descifrar que es la clave privada. No es factible computacionalmente determinar la llave de descifrado, solamente dado el algoritmo y la clave de cifrado. Además, algunos algoritmos, como RSA, también exhiben la siguiente característica:

• Cualquier clave, de las dos que se utilizan, se puede utilizar para el cifrado y la otra para el descifrado.

• Cada sistema final en una red genera el par de claves que se van a utilizar para cifrar los mensajes a emitir, y descifrar los mensajes que se recibirán.

• Cada sistema publica su clave de cifrado, situándola en un registro o fichero público. Esta es la clave pública. La clave compañera se mantiene privada.

• Si A desea enviar un mensaje a B, cifra el mensaje utilizando la clave pública de B. • Cuando B recibe el mensaje, lo descifra utilizando la clave privada de B. Ningún

otro destino puede descifrar el mensaje, ya que solamente B conoce la clave privada. Por la propiedad de las parejas de claves citada antes, para enviar un mensaje de forma confidencial a un destinatario basta cifrarlo con la clave pública de ese destinatario. Así sólo él podrá descifrarlo mediante la clave privada que mantiene en secreto. No es necesario que el remitente y el destinatario intercambien previamente ninguna clave secreta. El remitente sólo necesita averiguar la clave pública del destinatario. Para evitar posibles suplantaciones de identidad, es necesario contar con una tercera parte fiable que acredite de forma fehaciente cuál es la clave pública de cada persona o entidad. Esta es la función básica de las autoridades de certificación, como se muestra en la Figura 1.8.

Figura 1.8 Criptografía asimétrica


19

Con esta técnica, todos los participantes tienen acceso a las claves públicas, y las claves privadas se generan localmente por cada participante, por tanto, nunca se distribuyen. Mientras un sistema controle su clave privada, los mensajes que le llegan son seguros. Un sistema puede cambiar su clave privada en cualquier instante de tiempo y publica la clave pública compañera para reemplazar la clave pública obsoleta. Características de Criptografía de clave- asimétrica

• Clave pública para cifrar. • Clave privada para descifrar.

A partir del conocimiento de la clave pública no es posible determinar la clave privada, ni descifrar el texto con ella. Los sistemas de clave pública permiten, además, cumplir los requisitos de integridad del mensaje, autenticación y no repudio del remitente. Algoritmos de Criptografía de clave- asimétrica RSA El sistema criptográfico con clave pública RSA, es un algoritmo asimétrico cifrador de bloques, que utiliza una clave pública, la cual se distribuye (en forma autenticada preferentemente), y otra privada, la cual es guardada en secreto por su propietario. Una clave es un número de gran tamaño, que una persona puede conceptualizar como un mensaje digital, como un archivo binario o como una cadena de bits o bytes. Cuando se quiere enviar un mensaje, el emisor busca la clave pública de cifrado del receptor, cifra su mensaje con esa clave, y una vez que el mensaje cifrado llega al receptor, éste se ocupa de descifrarlo usando su clave oculta. Los mensajes enviados usando el algoritmo RSA se representan mediante números y el funcionamiento se basa en el producto de dos números primos grandes (mayores que 10100) elegidos al azar para conformar la clave de descifrado. Emplea expresiones exponenciales en aritmética modular. La seguridad de este algoritmo radica en que no hay maneras rápidas conocidas de factorizar un número grande en sus factores primos utilizando computadoras tradicionales.

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

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

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

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

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

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

http://es.wikipedia.org/wiki/N%C3%BAmero_primo


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

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


20

MD5 El algoritmo de hash más utilizado en estos momentos es el MD5 (Figura 1.9). Este algoritmo fue desarrollado por Ronald Rivest en 1995 y está basado en dos algoritmos anteriores MD2 y MD4. Todos estos protocolos producen un número de 128 bits a partir de un texto de cualquier longitud. MD4 fue desarrollado para mejorar el rendimiento de MD2, sin embargo, varios problemas fueron detectados, en 1996 fueron publicados elementos que hacen hoy en día inservible el algoritmo. MD5 sustituyó a MD4 y aunque no tiene el rendimiento de su antecesor, hasta el momento no han sido publicados elementos que comprometan su integridad y funcionamiento. MD5 comienza rellenando el mensaje a una longitud congruente en módulo 448 mod 512. Es decir la longitud del mensaje es 64 bits menos que un entero múltiplo de 512. El relleno consiste en un bit en 1, seguido por cuentos bits en 0 sean necesarios. La longitud original del mensaje es almacenada en los últimos 64 bits del relleno.

Figura 1.9 Algoritmo MD5

Adicionalmente se inicializa, con un valor fijo, un buffer de 128 bits. Este buffer puede verse como 4 registros de 32 bits (A, B, C, D) y son inicializados con los siguientes valores hexadecimales: A=67452301; B=EFCDAB89; C=98BADCFE; D=10325476 Durante varias rondas de procesamiento el algoritmo toma bloques de 512 bits de la entrada y los mezcla con los 128 bits del buffer. Este proceso es repetido hasta que todos los bloques de entrada han sido consumidos. El valor resultante en el buffer es el hash del mensaje. MD5 no es el único algoritmo de hash conocido. Existe otra función llamada Secure Hash Algorithm, (SHA), desarrollado por NSA a diferencia de MD5, SHA genera números hash de 160 bits.


21

1.8 Certificados de Seguridad Electrónicos

Para generar confianza en el usuario, el entorno Internet ha de ser seguro. Por ello, los estados han venido trabajando para resolver esos problemas hasta llegar a definir lo que ya podemos llamar “identidad digital”. Esto es algo así como un DNI o identificador digital único dentro de la red que permite a su poseedor ser identificado como tal dentro de la misma.

Los certificados electrónicos son dispositivos que posibilitan el almacenamiento de diversos datos relativos al propietario de los mismos (datos personales, claves, etc) y permiten identificarlo en la red, garantizando tanto la emisión de los datos, como su recepción, la integridad de la información transmitida, la confidencialidad y lo más importante, el no repudio de la transacción.

Un certificado electrónico es un documento firmado electrónicamente por un prestador de servicios de certificación que vincula unos datos de verificación de firma a un firmante y confirma su identidad. El firmante es la persona que posee un dispositivo de creación de firma y que actúa en nombre propio o en nombre de una persona física o jurídica a la que representa.

Estos certificados deben ser emitidos por las autoridades de certificación, también conocidas con el nombre de proveedores de servicios de certificación. Al igual que existe una firma electrónica general y otra cualificada, en el caso de los certificados de seguridad se habla también de certificados ordinarios y certificados reconocidos. Estos últimos son certificados que ofrecen mayores garantías, ya que, reúnen una serie de requisitos que aumentan su seguridad.

Como mínimo un certificado reconocido incluirá los siguientes datos:

1. La indicación de que se expiden como tales. 2. El código identificativo único del certificado. 3. La identificación del prestador de servicios de certificación que expide el certificado

y su domicilio. 4. La firma electrónica avanzada del prestador de servicios de certificación que expide

el certificado. 5. La identificación del firmante, en el supuesto de personas físicas, por su nombre y

apellidos, por su número de documento nacional de identidad o a través de un seudónimo que conste como tal de manera inequívoca y, en el supuesto de personas jurídicas, por su denominación o razón social y su código de identificación fiscal.

6. Los datos de verificación de firma que correspondan a los datos de creación de firma que se encuentren bajo el control del firmante.

7. El comienzo y el fin del período de validez del certificado. 8. Los límites de uso del certificado, si se establecen. 9. Los límites del valor de las transacciones para las que puede utilizarse el certificado.


22

Antes de la expedición de un certificado reconocido, los prestadores de servicios de certificación deberán cumplir las siguientes obligaciones:

1. Comprobar la identidad y circunstancias personales de los solicitantes de certificados.

2. Verificar que la información contenida en el certificado es exacta y que incluye toda la información prescrita para un certificado reconocido.

3. Asegurarse de que el firmante está en posesión de los datos de creación de firma correspondientes a los de verificación que constan en el certificado.

4. Garantizar la complementariedad de los datos de creación y verificación de firma, siempre que ambos sean generados por el prestador de servicios de certificación.

Clases de Certificados

• Certificados de Servidor

El Certificado de Servidor aporta a un WEB SITE la característica de seguridad y confianza necesaria para poder entablar cualquier tipo de relación con los potenciales usuarios. Es el elemento necesario para poder aprovechar la gran vía de negocio que supone el comercio a través de Internet con la máxima rentabilidad y seguridad. Los Certificados de Servidor permiten incorporar el protocolo SSL (Secure Socket Layer) en un servidor Web. Gracias a este protocolo toda comunicación entre el cliente y el servidor permanece segura, cifrando la información que se envía a ambos puntos, protegiendo los datos personales, datos de tarjetas de crédito, números de cuenta, passwords, etc. Cobra especial importancia dentro del área del comercio electrónico, donde la seguridad de los datos es la principal barrera para el desarrollo de este sistema.

• Certificados para WAP

Los Certificados WAP permiten a las WEB comerciales existentes y de nueva creación la realización de transacciones seguras con los consumidores móviles. Los nuevos portales basados en transacciones móviles seguras expandirán el comercio electrónico entre los usuarios móviles y los WEB SITES dedicados al comercio. Los servidores WAP necesitan proporcionar seguridad y confianza a los usuarios potenciales. Esta es la base para que se establezca una contraprestación que satisfaga a ambas partes. Los Certificados WAP permiten mantener conexiones seguras basadas en encriptación y autenticación con dispositivos de telefonía móvil.


23

• Certificados Personales

Otorgan seguridad a los correos electrónicos basados en un standard S/MIME. Podrá firmar o cifrar los mensajes de correo para asegurarse de que sólo el receptor designado sea el lector de nuestro mensaje.

• Autoridad Certificadora (AC) Corporativa

Es la solución óptima para las empresas que quieran disponer de un sistema de generación de cualquier tipo de Certificado para sus usuarios (trabajadores, proveedores, clientes, etc.) y servidores. Una AC Corporativa puede generar cualquier tipo de certificado, ya sean Certificados Personales, de Servidor, para WAP, para firmar Código e incluso para IPSec-VPN. En función del tipo de funcionalidad que se le quiera dar a la AC se deberá escogerse un diferente tipo de AC Corporativa.

• Certificados para firmar Código

El Certificado para la Firma de Código, permitirá a un Administrador, Desarrollador o Empresa de Software firmar su Software (ActiveX, Applets Java, Plug-ins, etc.) y Macros, y distribuirlo de una forma segura entre sus clientes.

• Certificados para IPSec-VPN

Los Certificados para VPN son los elementos necesarios para que la empresa aproveche las cualidades y ventajas de la utilización de las VPN´s de un modo plenamente seguro. Las VPN´s surgen como consecuencia de la creciente demanda de Seguridad en las comunicaciones ya sea entre Router-Router o Cliente-Servidor. La apertura de las redes corporativas a empleados remotos (con gran importancia en el caso del Teletrabajo, sucursales, business, partners o clientes).

Ventajas

Mediante la utilización de los certificados electrónicos, tanto las transacciones electrónicas como cualquier otra clase de transmisión de información a través de Internet, estará más protegida, originándose de esta forma una mayor confianza y seguridad en los usuarios en relación con los contenidos de los mensajes enviados y recibidos.

Su mayor ventaja es la certeza que produce sobre la identificación de la persona que envía un determinado mensaje, ya que autentifica fehacientemente la identidad del emisor.


24

La Autoridad Certificadora.

La Autoridad Certificadora, es la entidad que asegura la identidad de los usuarios de los certificados digitales. Posee su propio par de claves y firma digitalmente los certificados con su clave privada. Confiando en la Firma Digital de la Autoridad Certificadora, puede confiarse en cualquier certificado generado por la misma.

Las tareas realizadas por la Autoridad Certificadora son, entre otras, las siguientes:

• Procesa peticiones de Certificado a través de la Autoridad de Registro. Estas solicitudes están compuestas básicamente por los datos identificativos y la clave pública del solicitante.

• Genera los Certificados y los almacena en el repositorio público (p.e. LDAP). • Gestiona la caducidad y renovación de certificados. • Gestiona la revocación de certificados (p.e. por compromiso de la clave privada del

usuario al serle sustraída su SmartCard).

Toda la fiabilidad de la Autoridad de Certificación se basa en la inviolabilidad de su propia clave privada, la cual resulta crítico proteger empleando medios técnicos y humanos.

1.9 PKI

Infraestructura de clave pública (o, en inglés, Public Key Infrastructure) es una combinación de hardware y software, políticas y procedimientos de seguridad que permiten la ejecución con garantías de operaciones criptográficas como el cifrado, la firma digital o el no repudio de transacciones electrónicas .El término PKI se utiliza para referirse tanto a la autoridad de certificación y al resto de componentes.

Una PKI bien construida debe proporcionar:

• Autenticidad.- la firma digital tendrá la misma validez que la manuscrita. • Confidencialidad, de la información transmitida entre las partes. • Integridad.- debe asegurarse la capacidad de detectar si un documento firmado ha

sido manipulado. • No Repudio, de un documento firmado digitalmente.

En toda PKI deben establecerse los mecanismos para que los usuarios soliciten su propio certificado, de tal forma que se asegure la identidad de dicho usuario. A este procedimiento se le denomina "Proceso de Registro" y se realiza a través de la denominada "Autoridad de Registro".

http://es.wikipedia.org/wiki/Idioma_ingl%C3%A9s

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

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

http://es.wikipedia.org/wiki/Pol%C3%ADticas_de_seguridad


25

Existen dos tipos principales de registro:

• Registro Clásico. El solicitante acude en persona a una "Oficina de Registro", donde, tras acreditar su identidad, se le proporciona de forma segura su clave privada y su certificado.

• Registro Remoto. El usuario, a través de Internet, realiza una solicitud de certificado. Para esto empleará un software (p.e. un navegador) que generará el par de claves y enviará su clave pública a la Autoridad de Registro para que sea firmada por la Autoridad Certificadora y le sea devuelto su certificado.

La validez de la Firma Digital estará condicionada por la calidad del proceso de registro, siendo obligatorio para asegurar la validez legal de la firma, algún tipo de registro "Cara a Cara", ya que es el único que asegura la identidad del solicitante. Por otra parte, la validez de la firma digital también estará condicionada a la firma manuscrita de un "contrato" por el que el solicitante acepta su certificado y las condiciones de uso del mismo.

Componentes de una PKI

La Autoridad de Registro se compondrá de una serie de elementos tecnológicos (hardware y software específico) y unos medios humanos (los Operadores de Registro). Es el punto de comunicación entre los usuarios de la PKI y la Autoridad certificadora. Los sistemas anteriormente descritos deben englobarse en un único sistema, al que se denomina "Infraestructura de Clave Pública" (PKI), cuyo elementos se pueden ilustrar en la Figura 1.10.

Figura 1.10 Componentes de una PKI


26

Existen multitud de componentes adicionales, y cada elemento es un sistema complejo en si mismo. Los componentes básicos pueden resumirse en:

• La Autoridad de Certificación. La pieza central del "puzzle" y la que proporciona la base de confianza en la PKI. Constituido por elementos hardware, software y, evidentemente, humanos.

• Publicación de Certificados. El repositorio de certificados permite a los usuarios operar entre ellos (p.e. para la validación de una Firma Digital), y es un requisito legal que cuente con una total disponibilidad de acceso.

• Soporte de la Clave Privada. La elección de un buen soporte para que los usuarios custodien su clave privada es un punto esencial y complejo en sí mismo (p.e. si la clave está en una SmartCard, es necesario diseñar el Sistema de Gestión de SmartCards que permita la emisión y distribución de las tarjetas a los usuarios).

• Aplicaciones "PKI-Enabled". Se denomina así a las aplicaciones software capaz de operar con certificados digitales. Estas aplicaciones son las que dan el valor real de la PKI de cara al usuario.

• Políticas de Certificación. Deben diseñarse una serie de políticas, o procedimientos operativos, que rigen el funcionamiento de la PKI y establecen los compromisos entre la Autoridad Certificadora y los Usuarios Finales. El Proceso de Construcción de una PKI deberá siempre partir de la definición de las Políticas Operativas y contemplar como requerimiento esencial el asegurar la calidad y seguridad de las operaciones que los usuarios finales realizan con sus claves privadas (p.e. Firma Digital de Documentos).

27

CAPITULO II

ARQUITECTURA

Arquitectura Estándar para Identificación Digital Capítulo II Arquitectura

28

2. ARQUITECTURA El proyecto, como su nombre lo indica, busca la creación de una arquitectura de fácil acceso, uso e implementación, es decir, que pueda y deba ser utilizada en cualquier plataforma u organización, que sea una Arquitectura Estándar para la Identificación Digital (AEspID) con pocas o ninguna adecuaciones. Esto es posible debido a que la AEspID es completamente independiente a los sistemas de información ya existentes en las organizaciones. La Arquitectura Estándar para la Identificación Digital (AEspID), es un sistema el cual nos permite crear dichas identificaciones y de igual manera identificar con seguridad a las personas y los documentos que esta contenga, con procedimientos que nos indicarán si realmente la identificación es válida y está disponible para su uso. Dentro de la Arquitectura Estándar, en lo general, existen varias formas de dar seguridad y crear las identificaciones, pero debe existir algún órgano que administre todos los movimientos de la aplicación, movimientos como el crear las mismas identificaciones hasta verificar que sean válidas. Este órgano es la Autoridad Certificadora. En el presente proyecto se implementará una Infraestructura de Llave Pública de Única Autoridad Certificadora (PKI de única AC), con la finalidad de crear identificaciones digitales para los usuarios, constituidas por:

• Un certificado de Llave Pública, a nombre del usuario.

• Documentos en formato PDF.

• Y las firmas digitales correspondientes a cada documento.


29

La Figura 2.1 muestra el contenido de las identificaciones digitales.

Figura 2.1 Ejemplo grafico de la Identificación Digital generada por la arquitectura AEspID

En la consecución de dicho objetivo se delimitaron los siguientes tres módulos:

• El módulo de Validación e Interpretación de la Identificación Digital.

• El módulo de Certificación de Usuarios y Firma de Documentos.

• Y el módulo de Servicios de Certificación que implicaba la configuración del

servidor central.

La arquitectura propuesta se enfoca en el manejo de documentos firmados, por tal motivo y a diferencia de las implementaciones comunes de Infraestructuras de Clave Pública, el manejo de la clave privada de los usuarios queda a disposición de la Autoridad de Certificación y no del usuario, permitiendo la generación adecuada de las firmas de los documentos que contendrá la identificación digital.

AEspID_ID

Documentos Firmas Certificado de Usuario


30

Figura 2.2 Modulos de Certificación

En la figura 2.2, se puede observar con mejor claridad lo mencionado en el punto anterior, donde en el módulo de certificación son generadas todas las llaves privadas y son almacenadas en la base de datos del servidor, mientras que el certificado de usuario y firmas de los documentos quedan a disposición del usuario. Este módulo de certificación es controlado por la autoridad certificadora, la cual tiene dominio total sobre de él. Esta información es almacenada en una carpeta única, segura y disponible dentro del servidor de la autoridad certificadora y al usuario se le proporciona, en un dispositivo de almacenamiento portátil, la identificación correspondiente al mismo (llaves, certificados y firmas de documentos digitales). Una vez que le es proporcionada dicha información al usuario, este conectará dicho dispositivo a su computadora, la cual ejecutará automáticamente un archivo que llamará al servidor correspondiente a la autoridad certificadora. Dicha autoridad certificará o revocara la identificación del usuario y emitirá una advertencia al usuario ó a la organización según corresponda.

Organización

AC Auxiliar AEspID

Usuario

PKI de única AC

Pertenece

Firmas de Documentos Certificado

de Usuario

Certificado AEspID

Certifica

Auxilia

Llave Privada del Usuario

Llave Privada AEspID

BD

Revocación de Certificados Información del Sistema Interpretación y Validación

de la Identificación Digital

SERVICIOS

MODULO DE CERTIFICACIÓN

31

CAPITULO II I

DESARROLLO DE LA PROPUESTA

Arquitectura Estándar para Identificación Digital Capítulo III Desarrollo De la Propuesta

32

3. IMPLEMENTACIÓN Dentro de la implementación del sistema y como se menciona en la parte anterior de Arquitectura, denotaremos tres módulos significativos comenzando con el módulo de certificación. 3.1 Módulo de Certificación de Usuarios y Firma de Documentos Este módulo es el encargado de:

• Generar el certificado de llave pública y la llave privada de la autoridad de certificación.

• Generar los certificados de llave pública y las llaves privadas de los usuarios. • Generar las firmas de los documentos pertenecientes a los usuarios que hayan sido

validados y digitalizados previamente. • Generar el archivo de la identificación con la recopilación de los documentos antes

mencionados, además de los archivos extra necesarios para la interpretación de la identificación.

Este módulo esta desarrollado en Java debido a que este nos permite montarlo sobre sistemas operativos Linux y Windows. Podemos conceptualizar la identificación generada como un conjunto de documentos electrónicos con firma digital que permitan con cierto grado de veracidad identificar a una persona, y que dichos archivos fueron generados por el sistema de certificación y firmas del proyecto AEspID (Arquitectura Estándar Para Identificación Digital). Un ejemplo de la identificación se muestra en las Tablas 1 y 2.

Directorio ID_AEspID CertUsuario.pem Certificado del usuario Escanear0004.jpg Documento en formado JPEG Escanear0004.sig Firma del único documento

Tabla 1. Ejemplo de Identificación


33

3.1.1 Los certificados Tanto el certificado de llave pública del usuario como el de la Autoridad de certificación siguen el estándar X.509 y se guarda con formato DER. Al algoritmo de cifrado de estos certificados es para ambos SHA1 con RSA de 2048 bits. Un ejemplo de cómo se interpretan los certificados se muestra en la Tabla 3. Interpretación del certificado de la AC en el Sistema 3.1.2 Las Firmas Las firmas son documentos creados a partir del arreglo de bytes obtenido de los documentos a firmar (que puede ser de máximo 642 bits), por lo que pareciera información basura cuando se muestra interpretado en caracteres. La extensión “.sig” de las firmas fue propuesta por el proyecto, pero no es un estándar, y proviene de la palabra en inglés “signature” que significa firma. CertUsuario.cer

0‚_¨0‚_� ______w|;&0 _ *†H†÷ _____0_1_0___U__ESIME_AEspID0__ 070524180245Z_ 080524180245Z0_1_0___U__Juan d Castro 0‚_ 0 _ *†H†÷ ______‚_ _0‚___‚___ì_.Ò Ú(0±µo:Ëþ´~œîÀS‘cç´[T‘B[¨w.¡Ë_äÐúèKÝ¼IéP‰:àÐò;�_yŠ°O*-_¼â½?ŽÎÞ›+_¥Ö–M‘µ:¢{%_RÈÊ‘___¦;ý¶C_šØ°X_B_ámn_á)€…ô¥MSJá_ \_{µ_h5_¯'©__#�6ºûÊÚQ’ó¸“í_0Ò¼ïœ.ãKŸ¼z§ún»€¾‚Ãk…oC_x)¤“…ËŠ$u•_¢Bƒ“ï_w¢ ²ð2‘_#_DçdU_¢d__M´êj$›¾¥CÁÑ�`ä±!7¯}Ä¥åŸ`k1p3õD\Uì_‹wÑ8bÃ½ ¼ñ÷Púnè-1{___0 _ *†H†÷ ______‚___–ú“Î¾±_ÚçC8+ÿ·}·í'f_]i?j™B+o¶•vþRCŒ„¥:ÎÇ¹P #§pf2,õ�ªÑÅ¯_&%o2©ŒtCdØ4ÊãüìÎpaLÝ³NdîqØ2+Ý_ËuÐr>û__Rl¼0bÐêo>Õ“sW_„Ë«æR~WÙ1ˆ¹?°ÖdNÿVùèH<f|GÛÌ…Õ4fA[=öã8ò†ÀxML__“¦ ™�þ�š_LÉƒÚB�÷ò‡<ù“àÖLt�ä¤‚½ž_Â÷ègâÿ_ó—_°Øú÷¾:ò8)4§LÝ`V ð BÑ¯øºÿ´ÐË_^_™˜__Ú2Ê«_Õe_DÓð×1@Iö_ šÞbônÕ{Ì¢


34

Credencial de Elector.pdf

Credencial de Elector.sig

_(e0Ñ�ö›Õ‘óŽ�âbõ�üàÅ__“Ô-ÔÝí ÛÀæ~_=_oÛ\ £Ô…_Ý{F�¦(S_ÇUzÈŸÛ·Ô,õ�_ÎròZ=aüÔ|æ…á R8/¦:_t—_ÎÒÂ_¿ëg”¦é·‘Ç_+ÊrHŽ× «ìaMœÑvû©ÙâŠ»¼ œ1_I__pv¡dA_5[Pv_«y„6t•d V¬¶xQ~Ó"óWn‰¬-:zUF_êE_èðÍ0-WO»¼ ® 8†I'%Ýñ_[�ƒ¿Ö0v/V×í@Ñõ ™ÿ‹&ü�Õ³_þž5á¡ñÐ·¢Â1i_ûœ§ V_s#»KÈ=n_ÌÖo_ÿ†b@ˆ_q%bø3

Tabla 2. Ejemplo de identificación real

Version: V3 Subject: CN=Instituto PolitÃ©cnico Nacional - AEspID Signature Algorithm: SHA1withRSA, OID = 1.2.840.113549.1.1.5 Key: Sun RSA public key, 2048 bits modulus: 18775697425511676817169221287953796038556955102462327874633475122648792695115716419969658147381766486760970118326607139338830370109198278013557194766339298107487051360444515943083627627565316085309440835241029958188699239225704598295490222380996373487347892224309515943669593336367389393920562673933327925009431251049312425717876953742077766120546155547225676169127777848492945431946719084570209709882772627357922841367853105214906134077564497704848771182847133942461175716958592420932522470366523314231582230063387049672566588465094558313232869596842709938930336247993021984923938727818551385593074241310031793735201 public exponent: 3 Validity: Issuer: CN=Instituto PolitÃ©cnico Nacional - AEspID SerialNumber: [ 07d7]


35

] Algorithm: [SHA1withRSA] Signature: 0000: 29 7D DF 9C B9 7E 7E 4D BE C4 EE 36 E6 DE F7 84 )......M...6.... 0010: 20 F7 02 33 F7 47 9B 4C DA 0F 82 F5 CD 54 EA 23 ..3.G.L.....T.# 0020: 1E 94 43 1F B6 8E 8B 8C 0C 0A DC FC 78 1B 49 1D ..C.........x.I. 0030: 0A 80 29 3E 35 94 4D 8E 98 BC 44 67 B0 67 DC 28 ..)>5.M...Dg.g.( 0040: 19 F0 92 7D E0 B9 1D 16 15 1E B0 D9 61 19 49 3E ............a.I> 0050: 9B CA FF 01 21 12 8F E0 F6 8E DE 92 BE FE 23 2E ....!.........#. 0060: EB F1 DF 60 C3 24 31 EF 8E 0D EB BE ED DD 65 C9 ...`.$1.......e. 0070: C5 BF 57 73 A2 57 72 DD 93 7F 9C 83 58 E1 E2 7E ..Ws.Wr.....X... 0080: DF 04 8F D9 C4 AC C2 B2 31 B0 53 6B CF 0C EE C6 ........1.Sk.... 0090: 67 87 7D 80 90 0F 21 A5 E7 5D 27 81 F2 C1 C9 B8 g.....!..]'..... 00A0: 52 61 A6 1F F5 B6 C9 67 77 12 67 E5 94 B6 0B 76 Ra.....gw.g....v 00B0: 10 AB 92 1B 19 42 2E 17 D3 26 B7 F3 A4 F0 76 2F .....B...&....v/ 00C0: 33 4E F5 5E 92 AB DF FA 75 52 A5 2B 54 05 FC F9 3N.^....uR.+T... 00D0: 26 07 6C 6A 1A B4 67 06 4E 25 BD F6 5B 39 A2 AA &.lj..g.N%..[9.. 00E0: CB 67 1D E2 DA EB 75 94 C6 3B CB C6 3D 1A 17 80 .g....u..;..=... 00F0: DA A0 F5 F2 8A 06 41 90 6B 29 B5 90 C3 C1 5C D3 ......A.k)....\. ]

Tabla 3. Interpretación del certificado de la AC en el Sistema

3.1.3 Las Llaves Tanto el par de llaves de la AC, como el par del usuario, son llaves RSA de 2048 bits de longitud. Todas las llaves privadas se almacenan en la base de datos instalada en el Servidor, y la llave privada de la AC es antes cifrada con el algoritmo AES, utilizando una llave de 256 bits, la cual es producto del algoritmo SHA256 aplicado a un una frase de entre 6 y 12 caracteres. Para esta parte criptográfica del sistema, se utilizó la librería criptográfica de Bouncy Castle (BC).


36

3.1.4 Las interfaces


37

En cuestión a las interfaces del módulo de certificación:

• Se cuenta con una interfaz Utilidades, que permitirá crear la llave privada y

certificado de la AC, esta vista será cargada como principal en el caso de no haberse creado aún un certificado de AC. Permitirá también, limpiar la base de datos de los usuarios con certificados expirados. Figura 3.1

• La figura3.2 muestra la interfaz principal del sistema, la cual requerirá de una la clave root de la base de datos, además de la palabra de acceso para descifrar la llave privada de la AC. De esta forma permitir crear nuevo usuarios.

• La creación de un nuevo Usuario requerirá la interfaz de la figura 3.3, donde se deberá indicar la ruta donde crear el archivo de recopilación de documentos (identificación digital).

• La Interfaz de firma sólo podrá ser accedida después de crear un nuevo usuario o cargar un certificado de usuario ya existente. Figura 3.4

• Si existe un usuario, es posible añadir más documentos firmados a su identificación, a través de la interfaz de agregar. Figura 3.5

3.1.5 Navegación La Figura 3.6 ilustra este punto.

Figura 3.6 Navegación del módulo de certificación


38

3.2 Módulo de Validación e Interpretación de la Identificación Digital El presente módulo tendrá las siguientes funciones:

1. Validación de autenticidad de certificado de usuario. 2. Validación de fecha de expiración del certificado. 3. Validación de revocación de certificado. 4. Interpretación de la identificación.

Para la realización de este módulo se optó por desarrollarlo en Java, mediante la programación y desarrollo de un applet. El motivo por el cual, se eligió un applet como medio de desarrollo para dicho módulo, es que este nos presenta las siguientes ventajas:

• Es multiplataforma. • Se ejecuta del lado del cliente. • Es un lenguaje de alto nivel.

De los puntos mencionados anteriormente, destacaremos el segundo, que hace referencia a la ejecución del applet del lado del cliente. Este punto es de gran importancia para nosotros ya que, al ejecutarse la aplicación del lado del cliente, evitará una saturación por parte del servidor. Así mismo, nos ayudará a acceder al certificado y documentos del usuario que se encuentran almacenados en el dispositivo (memoria USB) del usuario. Por cuestiones de seguridad, un applet no puede acceder a los recursos del ordenador donde se está visualizando, ni disco duro, ni impresora, ni ninguna otra cosa. Tampoco puede establecer conexiones con otros ordenadores que no sean el servidor de dónde viene. Sin embargo, para dar funcionalidad al applet, a veces es necesario que este pueda acceder al disco duro. La forma de conseguir esto es firmar el applet digitalmente. Por esta razón nuestro applet cuenta con la firma digital de nuestra autoridad certificadora, cuando el navegador detecte que el applet ha sido firmado digitalmente nos mostrará un cuadro de mensaje informándonos que el applet ha sido firmado y si deseamos aceptar el applet.


39

3.2.1 Funcionamiento del módulo. Para iniciar la iteración del usuario con el applet, el usuario deberá conectar la memoria USB a la computadora, dentro del dispositivo se encuentra un archivo autoejecutable, el cual abrirá una página Web que servirá para pedir al servidor la ejecución del applet. Cuando el applet empiece a cargar, se mostrará una ventana en donde se puede observar la licencia de acrobat reader (figura 3.7), ya que, el visor de documentos pdf elegido fue este, aceptamos la licencia y el applet terminara de cargarse.

Figura 3.7 Licencia del Visor de Acrobat


40

3.2.2 Funciones del módulo 3.2.2.1 Validación de autenticidad de certificado de usuario Esta será la primera validación que realizará la aplicación. Validará si el certificado de usuario es válido, es decir, si el certificado localizado en la identificación fue creado por la Autoridad Certificadora (AC). Para esto, la aplicación se comunicará con el servidor, realizando una petición para obtener el certificado de la AC, esto para realizar la validación, ya que, el certificado de AC, se encuentra almacenado en el servidor. Una vez obtenido el certificado se realizará la validación correspondiente. Si el certificado no es válido, se mostrará un mensaje notificando al usuario de esta situación, como se ilustra en la figura 3.8.

Figura 3.8 Certificado no válido

3.2.2.2 Validación de fecha de expiración del certificado Consiste en verificar si el certificado no ha expirado, si la fecha de término de validez del certificado no ha sido superada. Al igual que el punto anterior, se realizará una comunicación con el servidor para obtener la fecha, esto debido a que si no se hace de esta manera, el usuario podría modificar la fecha del sistema, tal que, pueda hacer que el certificado apruebe esta validación.


41

Una vez obtenida la fecha del servidor, la aplicación realizará una comparación entre las fechas, si el certificado ha expirado se mostrará el mensaje correspondiente a esta situación. (Figura 3.9)

Figura 3.9 Certificado Expirado

3.2.2.3 Validación de revocación de certificado Para este punto, la aplicación verificará en la base de datos si el certificado no se encuentra revocado, para esto se obtiene el número de serie del certificado y se le envía al servidor en una petición, el servidor realizará la consulta y se devolverá una respuesta, la aplicación tomará la respuesta y lo validará, en caso de que, el certificado se encuentre revocado (Figura 3.10), se notificará al usuario sobre la revocación de su certificado.

Figura 3.10 Certificado Revocado


42

3.2.2.4 Interpretación de la identificación Una vez pasada todas las validaciones mencionadas anteriormente, se mostrarán la información del certificado del usuario; nombre del usuario, nombre de la AC, fecha de validez, así como, los documentos almacenados en la memoria USB, como se muestra en la Figura 3.11.

Figura 3.11 Identificación Correcta

Los documentos con los que cuenta la identificación se mostraran del lado derecho en una lista desplegable, de esta lista se podrá elegir el documento para visualizarlo en la parte superior. Al elegir el documento de la lista se verifica si este es válido, se comprueba si el documento ha sido firmado con el certificado del usuario, de ser así, me mostrará el mensaje “El documento es válido” (Figura 3.12), en caso contrario se mostrará el mensaje “El documento no es válido”. (Figura 3.13)


43

Un documento no es válido, cuando su firma no ha sido creada a partir del certificado del usuario, el motivo es que dicho documento fue firmado con otro certificado de usuario distinto al certificado localizado en la identificación. Se podría dar otro caso, en el cual el documento no se encuentre firmado, es decir se tiene el documento del usuario, pero este no ha sido firmado digitalmente con el certificado propio del usuario, en este caso se mostrará el mensaje “El documento no está firmado”. (Figura 3.14)

Figura 3.12 Documento válido


44

Figura 3.13 Documento no válido

Figura 3.14 Documento no firmado


45

3.3 Módulo de Servicios de Certificación 3.3.1 Revocación de Certificados Dentro de los servicios de certificación se encuentra la creación de páginas que permitirán:

1. Revocar certificados. 2. Proporcionar información del sistema y los requerimientos.

Esta páginas fueron creadas como jsp’s, las Figura 3.15, 3.16 y 3.17, son el despliegue de la páginas principales.

Figura 3.15 Página Principal de los servicios de Certificación

En la parte de revocación de certificados para que el certificado sea revocado automáticamente, la información pasa por dos validaciones, por una parte verifica si el Número de Serie está dado de alta, es decir, si existe un usuario con este Número de Serie con la posibilidad de revocar el certificado, en caso contrario se nos informará que el usuario no existe. (Figura 3.18)


46

La segunda verificación que hace el sistema es, en dado caso que el usuario exista en la base de datos, ahora se verifica que la contraseña que se acaba de ingresar es la correspondiente para el usuario y en caso contrario, nos mostrará un error. (Figura 3.19) En caso de haber pasado las verificaciones y correctamente (estar registrado en la base de datos y haber ingresado correctamente la contraseña) el sistema revocará el certificado impidiendo su uso futuro.

Figura 3.16 Página de Información


47

Figura 3.17 Página de revocación de certificados

Figura 3.18 Usuario no encontrado


48

Figura 3.19 Contraseña incorrecta

3.3.2 El Servidor El desarrollo de la Arquitectura Estándar para Identificación Digital nos exigía una aplicación ejecutándose en un servidor, esta aplicación nos ayudaría a crear y manipular gran parte del sistema, es por ello, que el servidor forma parte indispensable para nuestra aplicación. El saber que tecnologías se utilizarían para levantar el servidor y las características que este llevaría a una serie de investigaciones y decisiones para poder tener el servidor ideal para nuestra aplicación. El servidor nos ayudaría a implementar la aplicación la cual nos ayudaría a crear las identificaciones digitales, así como hacer las validaciones necesarias para determinar si dicha identificación es autentica o es corrupta, y por último nos daría la posibilidad de revocar certificados invalidando la identificación digital que contenga este.


49

Tras haber hecho la investigación, basándonos en las necesidades de nuestra aplicación decidimos levantar el servidor en un sistema operativo Linux. Elegimos como sistema operativo para la aplicación a Linux ya que, nos brinda un poco más de seguridad que la que nos brinda Windows, además de que el software que utilizaríamos es completamente libre y multiplataforma. Para la instalación del gestor de base de datos MySQL, obtuvimos ayuda de comandos los cuales nos ayudarían a descargarlo e instalarlo en nuestro servidor. Dicho comando es apt-get install mysql-server el cual al ejecutarlo, como mencionamos, inicia la descarga e inmediatamente después de descargarlo lo instala. Era turno de instalar nuestro servidor el cual nos ayudaría a conectar para algunas aplicaciones al cliente con nuestro servidor y ya que utilizaríamos Java en gran parte de estas comunicaciones, pues llegamos a la decisión de instalar Tomcat. Para su instalación necesitábamos tener instalado algún JDK en nuestra máquina lo cual lo hicimos de la siguiente manera: $ sudo apt-get install java-package $ sudo apt-get install fakeroot Con estos dos comandos instalaremos java-package y fakeroot, esto lo hacemos para poder convertir un fichero .bin en .deb. Enseguida bajamos el JDK que queremos en el servidor y lo instalamos de la siguiente manera: $ fakeroot make-jpkg jdk-1_5_0_09-linux-i586.bin Esto nos convertirá el .bin en .deb. Ahora sólo hay que instalar el .deb, para ello desde terminal ejecutamos: $ sudo dpkg -i sun-j2sdk1.5_1.5.0+update09_i386.deb Bueno ahora lo que haremos es asegurarnos de que el ordenador funciona con ésta última versión, para ello desde terminal tecleamos: $ sudo update-alternatives --config java Y nos aparecerá algo como esto: There are 5 alternatives which provide `java'. Selection Alternative ----------------------------------------------- 1 /usr/bin/gij-wrapper-4.1 + 2 /usr/lib/jvm/java-gcj/jre/bin/java 3 /usr/lib/jvm/java-1.5.0-sun/jre/bin/java * 4 /usr/lib/j2re1.5-sun/bin/java


50

5 /usr/lib/j2sdk1.5-sun/bin/java Press enter to keep the default[*], or type selection number: 5 Nosotros elegimos la 5 porque es la que nos corresponde. /usr/lib/j2sdk1.5-sun/bin/java Y para saber si lo hemos instalado correctamente debemos de teclear el siguiente comando el cual nos mostrará la versión de Java que provee los servicios. $java –version Y nos debe aparecer el siguiente texto: java version "1.5.0_09" Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_09-b01) Java HotSpot(TM) Client VM (build 1.5.0_09-b01, mixed mode, sharing) Y para terminar de configurar java correctamente hicimos lo siguiente: $ sudo update-alternatives --config jar There are 4 alternatives which provide `jar'. Selection Alternative ----------------------------------------------- 1 /usr/bin/fastjar + 2 /usr/lib/jvm/java-gcj/jre/bin/jar * 3 /usr/lib/jvm/java-1.5.0-sun/bin/jar 4 /usr/lib/j2sdk1.5-sun/bin/jar Press enter to keep the default[*], or type selection number: 4 Using `/usr/lib/j2sdk1.5-sun/bin/jar' to provide `jar'. $ sudo update-alternatives --config javac There are 2 alternatives which provide `javac'. Selection Alternative ----------------------------------------------- * 1 /usr/lib/jvm/java-1.5.0-sun/bin/javac + 2 /usr/lib/j2sdk1.5-sun/bin/javac Press enter to keep the default[*], or type selection number: 2 Using `/usr/lib/j2sdk1.5-sun/bin/javac' to provide `javac'. $ sudo update-alternatives --config javadoc


51

There are 2 alternatives which provide `javadoc'. Selection Alternative ----------------------------------------------- * 1 /usr/lib/jvm/java-1.5.0-sun/bin/javadoc + 2 /usr/lib/j2sdk1.5-sun/bin/javadoc Press enter to keep the default[*], or type selection number: 2 Using `/usr/lib/j2sdk1.5-sun/bin/javadoc' to provide `javadoc'. $ sudo update-alternatives --config javah There are 2 alternatives which provide `javah'. Selection Alternative ----------------------------------------------- * 1 /usr/lib/jvm/java-1.5.0-sun/bin/javah + 2 /usr/lib/j2sdk1.5-sun/bin/javah Press enter to keep the default[*], or type selection number: 2 Using `/usr/lib/j2sdk1.5-sun/bin/javah' to provide `javah'. $ sudo update-alternatives --config javap There are 2 alternatives which provide `javap'. Selection Alternative ----------------------------------------------- * 1 /usr/lib/jvm/java-1.5.0-sun/bin/javap + 2 /usr/lib/j2sdk1.5-sun/bin/javap Press enter to keep the default[*], or type selection number: 2 Using `/usr/lib/j2sdk1.5-sun/bin/javap' to provide `javap'. $ sudo update-alternatives --config javaws There are 3 alternatives which provide `javaws'. Selection Alternative ----------------------------------------------- 1 /usr/lib/jvm/java-1.5.0-sun/jre/bin/javaws *+ 2 /usr/lib/j2re1.5-sun/bin/javaws 3 /usr/lib/j2sdk1.5-sun/bin/javaws Press enter to keep the default[*], or type selection number: 3 Using `/usr/lib/j2sdk1.5-sun/bin/javaws' to provide `javaws'.


52

Y ya que tuvimos instalado Java correctamente era hora de instalar Tomcat, para ello lo descargamos de la página de apache y lo único que se tiene que hacer es descomprimirlo y llevarlo a la carpeta /usr/local/ y configurar Tomcat para que buscara el Java que se estaba ejecutando agregando las siguientes líneas al archivo /etc/profile: JAVA_HOME=/usr/lib/j2sdk1.5-sun PATH=$PATH:$JAVA_HOME/bin export PATH JAVA_HOME CATALINA_HOME=/usr/local/tomcat export CATALINA_HOME Ya agregadas estas líneas guardamos el archivo y ejecutamos lo siguiente en la línea de comando para que se actualizara: $ /etc/profile Y ahora si podíamos levantar el servidor haciendo lo siguiente: $sudo /usr/local/tomcat/bin/startup.sh Podemos ver que se ha levantado correctamente visualizando en el navegador su página inicial al dar en la url: http://localhost:8080. Para completar la instalación sencilla de Tomcat en modo seguro es necesario generar un certificado autofirmado y almacenarlo en un repositorio de claves (keystore) al alcance de Tomcat. Los certificados se almacenan en los repositorios asociándoles un alias. En el caso de Tomcat, la configuración por defecto busca el certificado con alias tomcat. Los keystores se protegen con una clave. Por defecto, dicha clave es changeit. El uso de la herramienta keytool para generar un keystore con un certificado autofirmado es este: %JAVA_HOME%\bin\keytool –genkey –alias tomcat –keyalg RSA Al introducir los datos relativos al certificado, es importante emplear el nombre del servidor como CN (common name). Otros datos solicitados son: unidad organizativa, organización, provincia, ciudad y país. La ejecución del comando anterior genera un fichero llamado .keystore. Y en seguida de esto generamos una solicitud de certificado partiendo del par de claves generado en el paso previo: %JAVA_HOME%\bin\keytool –certreq –alias tomcat –file newreq.pem Hecho esto era hora de configurar el Tomcat para que tomara los cambios efectuados modificando el archivo server.xml que se encuentra en la carpeta de configuración de Tomcat. Para ello añadimos el siguiente fragmento de código en dicho archivo:

http://localhost:8080/


53

<Connector port="8443" minSpareThreads="5" maxSpareThreads="75" enableLookups="true" disableUploadTimeout="true" acceptCount="100" maxThreads="200" scheme="https" secure="true" SSLEnabled="true" keystoreFile="aespid/keystore" keystorePass="aespid0026" clientAuth="false" sslProtocol="TLS"/> Finalmente reiniciamos el servidor: $sudo /usr/local/Tomcat/bin/shutdown.sh $sudo /usr/local/Tomcat/bin/startup.sh Y podemos ver dicha configuración ejecutándose al ir a la dirección https://localhost:8443 en nuestro navegador, el cual nos mostrará los avisos del certificado los cuales debemos aceptar para ver de nuevo la página inicial de Tomcat.

https://localhost:8443/

54

CONCLUSIONES


55

CONCLUSIONES

El presente trabajo de investigación ha demostrado su efectividad y funcionalidad, ya que como se cita en uno de los capítulos del mismo, es de vital importancia, para un pais o nacion como el nuestro que desea estar a la vanguardia tecnologica, el tener una herramienta que satisfaga la necesidad de la identificación de los ciudadanos de un país, el cual contenga los diversos documentos para dicho fin. Dicha arquitectura o sistema facilitaría los trámites gubernamentales de carácter oficial para los usuarios, ya que contendría los documentos oficiales expedidos por la autoridad correspondiente, la identidad jurídica y vivencial, así como el registro del individuo y la validez del mismo, documentos como: acta de nacimiento, identificación oficial con foto, pasaporte licencia de manejo, entre muchas otras. La arquitectura presentada satisface en gran medida esta demanda de un sistema de identificación ya que, además de tener una baja y casi nulo costo se tendría una autoridad certificadora la cual emitirá certificados para la aprobación o repudiación de dichas identificación, por lo tanto también se cubre la parte de la seguridad de dicha arquitectura de identificación digital. Es tal la importancia de dicha arquitectura o sistema de identificación, que al los días posteriores al término del mismo, el gobierno federal anuncio la creación de: Cédula de Identidad Ciudadana. La expedición de la cédula (Sistema o arquitectura de identificación digital) estará a cargo de la Secretaría de Gobernación (Segob, Autoridad Certificadora) y utilizará como llave la Clave Única del Registro de Población (CURP, Certificado de autentificación). Por ello se puede determinar que la investigación, desarrollo e implementación del presente proyecto tiene viabilidad, sustentabilidad y ante todo practicidad y funcionalidad, ya que es una arquitectura estándar que es posible implementar en cualquier ambiente computacional

Arquitectura Estándar para Identificación Digital Glosario

56

BIBLIOGRAFÍA

• Artículo: “Aplicaciones prácticas de la criptografía”, Ingeniera Informática Vera Delgado e Ingeniero Industrial Rafael Palacios.

• http://javabasico.osmosislatina.com/curso/progbasico/jars.htm • http://forum.java.sun.com/thread.jspa?forumID=256&threadID=205766 • http://manuales.dgsca.unam.mx/webdina/servlets.htm • http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=appletservlet • http://www.javahispano.org/articles.print.action?id=26 • Java ™ Cryptography Architecture (JCA) Reference Guide for JavaTM Platform

Standard Edition 6 • Java ™ Cryptography Architecture Sun Providers Documentation for JavaTM

Platform Standard Edition 6 • Tesis Doctoral: “Contribución a la Validación de Certificados en Arquitecturas de

Autenticación y Autorización” Isabel Cristina Satizábal Echavarría Universidad Politécnica de Catalunya

57

GLOSARIO


58

Algoritmo.-un algoritmo (del latín, dixit algorithmus y éste a su vez del matemático persa kenvorrio) es una lista bien definida, ordenada y finita de operaciones que permite hallar la solución a un problema. Dado un estado inicial y una entrada, a través de pasos sucesivos y bien definidos se llega a un estado final, obteniendo una solución. Los algoritmos son objeto de estudio de la algoritmia Autoridad Certificadora.- es la entidad que asegura la identidad de los usuarios de los certificados digitales. Posee su propio par de claves y firma digitalmente los certificados con su clave privada. Autenticidad. La autenticación es un servicio de seguridad que permite verificar la identidad. Bits.- El bit es la unidad mínima de información empleada en informática, en cualquier dispositivo digital, o en la teoría de la información. Con él, podemos representar dos valores cuales quiera, como verdadero o falso, abierto o cerrado, blanco o negro, norte o sur, masculino o femenino, rojo o azul, etc. Basta con asignar uno de esos valores al estado de "apagado" (0), y el otro al estado de "encendido" (1). Buffer.- Es una memoria intermedia utilizada para guardar temporalmente la información que se transfiere entre diferentes dispositivos informáticos (o entre los componentes de un mismo sistema informático). Certificados electrónico.- Son dispositivos que posibilitan el almacenamiento de diversos datos relativos al propietario de los mismos (datos personales, claves, etc) y permiten identificarlo en la red, garantizando tanto la emisión de los datos, como su recepción, la integridad de la información transmitida, la confidencialidad y lo más importante, el no repudio de la transacción. Certificados WAP .- Los Certificados WAP permiten a las web comerciales la realización de transacciones seguras con los consumidores móviles. Los nuevos portales basados en transacciones móviles seguras expandirán el comercio electrónico entre los usuarios móviles y los WEB SITES dedicados al comercio. Los Certificados WAP permiten mantener conexiones seguras basadas en encriptación y autenticación con dispositivos de telefonía móvil. Chip.- Circuito integrado en un soporte de silicio, formado por transistores y otros elementos electrónicos miniaturizados. Son uno de los elementos esenciales de un ordenador y de cada vez más aparatos electrónicos de todo tipo. Literalmente significa astilla o patata frita. Confidencialidad: requiere que la información sea accesible únicamente por las entidades autorizadas. La confidencialidad de datos se aplica a todos los datos intercambiados por las entidades autorizadas o tal vez a sólo porciones o segmentos seleccionados de los datos, por ejemplo mediante cifrado.

http://es.wikipedia.org/wiki/Inform%C3%A1tica

http://es.wikipedia.org/wiki/Teor%C3%ADa_de_la_informaci%C3%B3n

http://tecnologia.glosario.net/terminos-tecnicos-internet/memoria-1073.html

http://tecnologia.glosario.net/terminos-tecnicos-internet/informaci%F3n-883.html

http://tecnologia.glosario.net/terminos-tecnicos-internet/sistema-1515.html


59

Contraseñas dinámicas (One Time Password), o en español “contraseña de un solo uso”, son aquellos que requieren una contraseña nueva cada vez que se utiliza. Una especie de contraseña de usar y tirar, que minimiza el impacto de que un tercero pueda capturarla. Criptografía.- es la técnica de transformar un mensaje inteligible, denominado texto en claro, en otro que sólo puedan entender las personas autorizadas a ello, que llamaremos criptograma o texto cifrado. El método o sistema empleado para encriptar el texto en claro se denomina algoritmo de encriptación o algoritmo criptográfico. Disponibilidad: requiere que los recursos del sistema informático estén disponibles a las entidades autorizadas cuando los necesiten. DNI electrónico.- Documento Nacional de Identidad electrónico (DNIe) responde a la necesidad de otorgar identidad personal a los ciudadanos para su uso en la nueva Sociedad de la Información, además de servir de impulsor de la misma. Así, el DNIe es la adaptación del tradicional documento de identidad a la nueva realidad de una sociedad interconectada por redes de comunicaciones. Integridad.-Se garantiza que los datos recibidos son exactamente iguales a los datos enviados, pero no se impide que al receptor la posibilidad de modificar estos datos una vez recibidos ISO 7816.- es un estándar internacional relacionado con las tarjetas de identificación electrónicas, en especial las tarjetas inteligentes, gestionado conjuntamente por la Organización Internacional De Normalización (ISO) y Comisión Electrotécnica Internacional (IEC). Se trata de una extensión de la ISO 7810. interfaz CMCIA. No Repudio, de un documento firmado digitalmente. Ofrece protección a un usuario frente a que otro usuario niegue posteriormente que en realidad se realizó cierta comunicación. Esta protección se efectúa por medio de una colección de evidencias irrefutables que permitirán la resolución de cualquier disputa. El no repudio de origen protege al receptor de que el emisor niegue haber enviado el mensaje, mientras que el no repudio de recepción protege al emisor de que el receptor niegue haber recibido el mensaje. Las firmas digitales constituyen el mecanismo más empleado para este fin. PKI.- En criptografía, una infraestructura de clave publica (o, en inglés, PKI, Public Key Infrastructure) es una combinación de hardware y software, políticas y procedimientos de seguridad que permiten la ejecución con garantías de operaciones criptográficas como el cifrado, la firma digital o el no repudio de transacciones electrónicas.El término PKI se utiliza para referirse tanto a la autoridad de certificación y al resto de componentes, como para referirse, de manera más amplia y a veces confusa, al uso de algoritmos de clave pública en comunicaciones electrónicas. Este último significado es incorrecto, ya que no se requieren métodos específicos de PKI para usar algoritmos de clave pública.


http://es.wikipedia.org/wiki/Est%C3%A1ndar

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

http://es.wikipedia.org/wiki/Organizaci%C3%B3n_Internacional_para_la_Normalizaci%C3%B3n

http://es.wikipedia.org/wiki/Comisi%C3%B3n_Electrot%C3%A9cnica_Internacional

http://es.wikipedia.org/wiki/Comisi%C3%B3n_Electrot%C3%A9cnica_Internacional

http://es.wikipedia.org/w/index.php?title=ISO_7810&action=edit&redlink=1

http://es.wikipedia.org/wiki/Criptograf%C3%ADa



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



http://es.wikipedia.org/wiki/Clave_p%C3%BAblica

http://es.wikipedia.org/wiki/Clave_p%C3%BAblica



60

Protocolo SSL (Secure Socket Layer).- El protocolo SSL es un sistema de seguridad desarrollado etscape y utilizado actualmente por la mayoría de empresas que comercian a través de Internet. Es un sistema de seguridad ideado para acceder a un servidor garantizando la confidencialidad de los datos mediante técnicas de encriptación modernas. Router-Router.- direccionador, ruteador o encaminador es un dispositivo de hardware para interconexión de red de ordenadores que opera en la capa tres (nivel de red). Un router es un dispositivo para la interconexión de redes informáticas que permite asegurar el enrutamiento Revocación.-Revocar un certificado es anular su validez antes de la fecha de caducidad que consta en el mismo. La revocación puede ser solicitada en cualquier momento, y en especial, cuando el titular crea que sus claves privadas son conocidas por otros. La revocación tiene efectos a partir de la fecha efectiva de revocación que consta junto al número de serie del certificado revocado en un documento firmado y publicado por la Autoridad de Certificación. Cualquier firma digital realizada con la clave privada asociada a ese certificado con posterioridad a la fecha efectiva de revocación no tendrá validez. Sistema operativo.- El sistema operativo es el programa (o software) más importante de un ordenador. Para que funcionen los otros programas, cada ordenador de uso general debe tener un sistema operativo. Los sistemas operativos realizan tareas básicas, tales como reconocimiento de la conexión del teclado, enviar la información a la pantalla, no perder de vista archivos y directorios en el disco, y controlar los dispositivos periféricos tales como impresoras, escáner, etc. SmartCard.- Una tarjeta inteligente (smart card), o tarjeta con circuito integrado (TCI), es cualquier tarjeta del tamaño de un bolsillo con circuitos integrados que permiten la ejecución de cierta lógica programada. Aunque existe un diverso rango de aplicaciones, hay dos categorías principales de TCI. Las Tarjetas de memoria contienen sólo componentes de memoria no volátil y posiblemente alguna lógica de seguridad. Las tarjetas microprocesadoras contienen memoria y microprocesadores. VPN.- Una VPN o Red Privada Virtual es una tecnología que permite la extensión de una red pública como Internet a un espacio de red local. En la informática una Red Privada Virtual (RPV) o Virtual Private Network (VPN) supone una tecnología de red que, por razones de costo y comodidad, brinda la posibilidad de conectarse a una red pública generando una extensión a nivel de área local. WEB .- Un servidor web, un programa que implementa el protocolo HTTP (hypertext transfer protocol) para transferir lo que llamamos hipertextos, páginas web o páginas HTML (hypertext markup language). WEB SITE .- Un sitio web (en inglés: website) es un conjunto de páginas web, típicamente comunes a un dominio de Internet o subdominio en la World Wide Web en Internet.Una página web es un documento HTML/XHTML accesible generalmente mediante el protocolo HTTP de Internet. Todos los sitios web públicamente accesibles constituyen una gigantesca "World Wide Web


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

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

http://www.unav.es/SI/servicios/seguridad/faq.html#8




http://www.masadelante.com/faq-software-hardware.htm

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

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

http://www.definicionabc.com/tecnologia/informatica.php

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

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

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

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


http://es.wikipedia.org/wiki/P%C3%A1gina_web

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

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

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

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

http://es.wikipedia.org/wiki/P%C3%A1gina_web

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

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

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

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

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

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

61

ANEXOS

Arquitectura Estándar para Identificación Digital Anexo I

62

ANEXO 1. CÓDIGO MÓDULO DE CERTIFICACIÓN ManejadorDeCertificado.java /* * ManejadorDeCertificado.java * */ package AEspID; import java.io.BufferedInputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.math.BigInteger; import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; import java.security.NoSuchProviderException; import java.security.PrivateKey; import java.security.PublicKey; import java.security.SignatureException; import java.security.cert.Certificate; import java.security.cert.CertificateEncodingException; import java.security.cert.CertificateException; import java.security.cert.CertificateFactory; import java.security.cert.X509Certificate; import java.util.Date; import org.bouncycastle.asn1.x509.X509Name; import org.bouncycastle.util.encoders.Base64; import org.bouncycastle.x509.X509V3CertificateGenerator; /** * @author Juan Diego */ public class ManejadorDeCertificado { private X509Certificate certificado; public ManejadorDeCertificado() {} public boolean crear(X509Name nombreAC,X509Name nombreUsuario,String nS,Date fechaInicio, Date fechaFin,PublicKey publica,PrivateKey privada)throws java.io.IOException{ X509V3CertificateGenerator certGen = new X509V3CertificateGenerator();


63

certGen.setSerialNumber(new BigInteger(nS)); certGen.setIssuerDN(nombreAC); certGen.setNotBefore(fechaInicio); certGen.setNotAfter(fechaFin); certGen.setSubjectDN(nombreUsuario); certGen.setPublicKey(publica); certGen.setSignatureAlgorithm("SHA1WithRSAEncryption"); try { certificado = certGen.generate(privada); } catch (InvalidKeyException ex) { return false; } catch (CertificateEncodingException ex) { return false; } catch (NoSuchAlgorithmException ex) { return false; } catch (SignatureException ex) { return false; } catch (IllegalStateException ex) { return false; } return true; } public boolean exportarPEM(String file)throws java.security.cert.CertificateParsingException, java.io.IOException{ String salto = "\n"; String beginCertificate = "-----BEGIN CERTIFICATE-----" +salto; String endCertificate = "-----END CERTIFICATE-----" +salto; FileOutputStream fos = new FileOutputStream(file); FileOutputStream fos2 = new FileOutputStream("test.cer"); fos.write(beginCertificate.getBytes()); byte[] certb64; try { certb64 = Base64.encode(certificado.getEncoded()); fos2.write(certificado.getEncoded()); int length = certb64.length; int bytestowrite = 64; for ( int written = 0; written < length; ) { fos.write(certb64,written,bytestowrite); fos.write(salto.getBytes()); written+=bytestowrite; if ( (length - written) < 64 ) { bytestowrite=(length - written); } }


64

fos.write(endCertificate.getBytes()); } catch (CertificateEncodingException ex) { return false; } fos.close(); fos2.close(); return true; } public boolean exportarCER(String file)throws java.security.cert.CertificateParsingException, java.io.IOException{ //File aux = new File(file); //if(aux.se) // System.out.println("si cambio el tipo, segun"); FileOutputStream fos = new FileOutputStream(file); try { fos.write(certificado.getEncoded()); } catch (CertificateEncodingException ex) { return false; } fos.close(); return true; } public int importar(String file){ try { FileInputStream fis = new FileInputStream(file); BufferedInputStream bis = new BufferedInputStream(fis); CertificateFactory cf = CertificateFactory.getInstance("X.509"); if (bis.available() > 0) { Certificate certAux = cf.generateCertificate(bis); certificado=(X509Certificate)certAux; } bis.close(); fis.close(); } catch (CertificateException ex) { return 1; } catch (FileNotFoundException ex) { return 2; } catch (IOException ex) { return 2; } return 0;


65

} public boolean verificar(PublicKey publica){ try { certificado.verify(publica); } catch (InvalidKeyException ex) { ex.printStackTrace(); return false; } catch (CertificateException ex) { ex.printStackTrace(); return false; } catch (SignatureException ex) { ex.printStackTrace(); return false; } catch (NoSuchAlgorithmException ex) { ex.printStackTrace(); return false; } catch (NoSuchProviderException ex) { ex.printStackTrace(); return false; } return true; } public PublicKey getPublicKey(){ return certificado.getPublicKey(); } public X509Name getX509Name(){ return new X509Name(certificado.getIssuerX500Principal().getName()); } public X509Certificate getX509Certificate(){ return certificado; } } ManejadorLlavesRSA.java /* * ManejadorLlavesRSA.java * */ package AEspID;


66

import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.BufferedReader; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.math.BigInteger; import java.security.KeyFactory; import java.security.KeyPair; import java.security.NoSuchAlgorithmException; import java.security.PrivateKey; import java.security.PublicKey; import java.security.cert.X509Certificate; import java.security.interfaces.RSAPublicKey; import java.security.spec.InvalidKeySpecException; import java.security.spec.RSAPrivateCrtKeySpec; import java.security.spec.RSAPublicKeySpec; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import java.util.Calendar; import org.bouncycastle.crypto.DataLengthException; import org.bouncycastle.crypto.digests.SHA256Digest; import org.bouncycastle.crypto.engines.AESEngine; import org.bouncycastle.crypto.params.RSAKeyParameters; import org.bouncycastle.crypto.params.RSAPrivateCrtKeyParameters; /** * * @author Juan Diego */ public class ManejadorLlavesRSA { private RSAKeyParameters publica; private RSAPrivateCrtKeyParameters privada; private KeyPair par; public ManejadorLlavesRSA() {}


67

public boolean crearLlaves(){ RSAUtils llaves=new RSAUtils(); llaves.setRSAMode(2); llaves.setKeyLength(2048); llaves.setCertaintyOfPrime(100); llaves.initRSAKeyPair(); publica = (RSAKeyParameters) llaves.getPublicKey(); privada = (RSAPrivateCrtKeyParameters) llaves.getPrivateKey(); try { par = new KeyPair(KeyFactory.getInstance("RSA").generatePublic( new RSAPublicKeySpec(publica.getModulus(), publica.getExponent())),KeyFactory.getInstance("RSA").generatePrivate( new RSAPrivateCrtKeySpec(publica.getModulus(), publica.getExponent(), privada.getExponent(), privada.getP(), privada.getQ(), privada.getDP(), privada.getDQ(), privada.getQInv()))); } catch (InvalidKeySpecException ex) { return false; } catch (NoSuchAlgorithmException ex) { return false; } return true; } public PrivateKey getPrivateKey(){ return par.getPrivate(); } public PublicKey getPublicKey(){ return par.getPublic(); } public boolean exportarLlavePrivadaProtegida(String pass,String passBD){ ByteArrayOutputStream byteArrayOS = null, salida = null; RSAPrivateCrtKeyParameters llavePrivAux = privada; SHA256Digest digester=new SHA256Digest(); digester.update(pass.getBytes(),0,pass.getBytes().length); byte[] hash = new byte[digester.getDigestSize()]; digester.doFinal(hash,0); BlockCipherTool cipherTool = new BlockCipherTool(); cipherTool.setEngine(new AESEngine()); byteArrayOS = new ByteArrayOutputStream();


68

BigInteger llavePrivAux_modulus = llavePrivAux.getModulus(); BigInteger llavePrivAux_exponent = llavePrivAux.getExponent(); BigInteger e = llavePrivAux.getPublicExponent(); BigInteger dP = llavePrivAux.getDP(); BigInteger dQ = llavePrivAux.getDQ(); BigInteger p = llavePrivAux.getP(); BigInteger q = llavePrivAux.getQ(); BigInteger qInv = llavePrivAux.getQInv(); try{ byteArrayOS.write(llavePrivAux_modulus.toString().getBytes()); byteArrayOS.write( '\n' ); byteArrayOS.write(e.toString().getBytes()); byteArrayOS.write( '\n' ); byteArrayOS.write(llavePrivAux_exponent.toString().getBytes()); byteArrayOS.write( '\n' ); byteArrayOS.write(p.toString().getBytes()); byteArrayOS.write( '\n' ); byteArrayOS.write(q.toString().getBytes()); byteArrayOS.write( '\n' ); byteArrayOS.write(dP.toString().getBytes()); byteArrayOS.write( '\n' ); byteArrayOS.write(dQ.toString().getBytes()); byteArrayOS.write( '\n' ); byteArrayOS.write(qInv.toString().getBytes()); byteArrayOS.write( '\n' ); byte [] llavePrivSinPass = byteArrayOS.toByteArray(); ByteArrayInputStream byteArrayIS = new ByteArrayInputStream(llavePrivSinPass); salida = new ByteArrayOutputStream(); cipherTool.init( true ,display(hash)); if(!cipherTool.Encrypt(byteArrayIS,salida)) return false; try { String url = "jdbc:mysql://localhost/AEspIDLlave"; String login = "root"; Connection conn = DriverManager.getConnection(url,login,passBD); Statement stmt = conn.createStatement(); stmt.executeUpdate("INSERT INTO LlavePrivada VALUES ('"+salida.toString()+"')"); stmt.close();


69

conn.close(); } catch (SQLException ex) { return false; } byteArrayIS.close(); } catch (IOException closing){ return false; } return true; } public int importarLlavesConPivadaProtegida(String pass,String passBD,PublicKey publicaAux){ ByteArrayInputStream keyinstream = null, llaveEncrip = null; ByteArrayOutputStream keyoutstream = new ByteArrayOutputStream(); SHA256Digest digester2=new SHA256Digest(); digester2.update(pass.getBytes(),0,pass.getBytes().length); byte[] hash = new byte[digester2.getDigestSize()]; digester2.doFinal(hash,0); BlockCipherTool cipherTool = new BlockCipherTool(); cipherTool.setEngine(new AESEngine()); RSAPrivateCrtKeyParameters RSAPrivParam = null ; cipherTool.init(false ,this.display(hash)); try { String url = "jdbc:mysql://localhost/AEspIDLlave"; String login = "root"; byte[] llave; Connection conn = DriverManager.getConnection(url,login,passBD); Statement stmt = conn.createStatement(); ResultSet rs; rs=stmt.executeQuery("SELECT Llave FROM LlavePrivada"); if(rs.last()){ llave=rs.getBytes("Llave"); if(llave.length!=0) llaveEncrip = new ByteArrayInputStream(llave); } rs.close(); stmt.close(); conn.close(); } catch (SQLException ex) { return 1; }


70

try{ if(!cipherTool.Decrypt(llaveEncrip,keyoutstream)) return 3; }catch(Exception e){ return 3; } byte [] privatekey_withtoutpass = keyoutstream.toByteArray(); keyinstream = new ByteArrayInputStream(privatekey_withtoutpass); BigInteger myprivkey_modulus = null ; BigInteger myprivkey_exponent = null ; BigInteger e = null ; BigInteger p = null ; BigInteger q = null ; BigInteger dP = null ; BigInteger dQ = null ; BigInteger qInv = null ; String readstr = null ; try { BufferedReader br = new BufferedReader( new InputStreamReader(keyinstream)); readstr = br.readLine(); myprivkey_modulus = new BigInteger(readstr); readstr = br.readLine(); e = new BigInteger(readstr); readstr = br.readLine(); myprivkey_exponent = new BigInteger(readstr); readstr = br.readLine(); p = new BigInteger(readstr); readstr = br.readLine(); q = new BigInteger(readstr); readstr = br.readLine(); dP = new BigInteger(readstr); readstr = br.readLine(); dQ = new BigInteger(readstr); readstr = br.readLine(); qInv = new BigInteger(readstr); RSAPrivParam = new RSAPrivateCrtKeyParameters(myprivkey_modulus, myprivkey_exponent, e,p,q,dP,dQ,qInv); privada = (RSAPrivateCrtKeyParameters) RSAPrivParam;


71

RSAPublicKey aux = (RSAPublicKey) publicaAux; publica=new RSAKeyParameters(false,aux.getModulus(),aux.getPublicExponent()); try { par = new KeyPair(KeyFactory.getInstance("RSA").generatePublic( new RSAPublicKeySpec(publica.getModulus(), publica.getExponent())),KeyFactory.getInstance("RSA").generatePrivate( new RSAPrivateCrtKeySpec(publica.getModulus(), publica.getExponent(), privada.getExponent(), privada.getP(), privada.getQ(), privada.getDP(), privada.getDQ(), privada.getQInv()))); } catch (InvalidKeySpecException ex) { return 4; } catch (NoSuchAlgorithmException ex) { return 4; } keyinstream.close(); keyoutstream.flush(); keyoutstream.close(); } catch (DataLengthException ex) { return 2; } catch (IllegalStateException ex) { return 2; } catch (Exception ex) { return 2; } return 0; } public int exportarEnBD(X509Certificate cert,String pass){ try { String url = "jdbc:mysql://localhost/AEspIDDB"; String login = "sistema"; Connection conn = DriverManager.getConnection(url,login,""); ResultSet rs; Statement stmt = conn.createStatement(); rs=stmt.executeQuery("SELECT NumeroSerie " + "FROM Usuarios WhERE NumeroSerie=" + cert.getSerialNumber().toString()); if(rs.next()){ return 1; }


72

String llave=privada.getModulus().toString()+" "+privada.getPublicExponent().toString() +" "+privada.getExponent().toString()+" "+privada.getP().toString()+" " +privada.getQ().toString()+" "+privada.getDP().toString()+" " +privada.getDQ().toString()+" "+privada.getQInv().toString(); Calendar cal=Calendar.getInstance(); cal.setTime(cert.getNotAfter()); stmt.executeUpdate("INSERT INTO Usuarios VALUES ("+cert.getSerialNumber().toString()+", '" +pass+"', '"+llave+"', '"+String.valueOf(cal.get(cal.YEAR)) +"-"+String.valueOf(cal.get(cal.MONTH)) +"-"+String.valueOf(cal.get(cal.DAY_OF_MONTH))+"', 0)"); stmt.close(); conn.close(); } catch (SQLException ex) { return 2; } return 0; } public String importarDeBD(X509Certificate cert){ Calendar cal=Calendar.getInstance(); if(cal.getTime().compareTo(cert.getNotBefore())>0){ try { String url = "jdbc:mysql://localhost/AEspIDDB"; String login = "sistema"; Connection conn = DriverManager.getConnection(url,login,""); ResultSet rs; Statement stmt = conn.createStatement(); rs=stmt.executeQuery("SELECT NumeroSerie,LlavePrivada,Revocado " + "FROM Usuarios WhERE NumeroSerie=" + cert.getSerialNumber().toString()); if(rs.next()){ if(rs.getInt("Revocado")==0){ String llave=rs.getString("LlavePrivada"); String[] llaveDiv = dividirLlave(llave); RSAPublicKey aux = (RSAPublicKey) cert.getPublicKey(); publica=new RSAKeyParameters(false,aux.getModulus(),aux.getPublicExponent()); try { par = new KeyPair(KeyFactory.getInstance("RSA").generatePublic(


73

new RSAPublicKeySpec(new BigInteger(llaveDiv[0]), new BigInteger(llaveDiv[1]))), KeyFactory.getInstance("RSA").generatePrivate( new RSAPrivateCrtKeySpec(new BigInteger(llaveDiv[0]), new BigInteger(llaveDiv[1]), new BigInteger(llaveDiv[2]), new BigInteger(llaveDiv[3]), new BigInteger(llaveDiv[4]), new BigInteger(llaveDiv[5]), new BigInteger(llaveDiv[6]), new BigInteger(llaveDiv[7])))); } catch (InvalidKeySpecException ex) { return "Error al importar las llaves"; } catch (NoSuchAlgorithmException ex) { return "Error al importar las llaves"; } }else return "Certificado Revocado"; }else return "Registro no existente"; rs.close(); stmt.close(); conn.close(); } catch (SQLException ex) { return "Error de conexion"; } }else return "Certificado Vencido"; return "Correcto"; } public static String display(byte[] array) { char[] val = new char[2*array.length]; String hex = "0123456789ABCDEF"; for (int i = 0; i < array.length; i++) { int b = array[i] & 0xff; val[2*i] = hex.charAt(b >>> 4); val[2*i + 1] = hex.charAt(b & 15); } return String.valueOf(val); } public static String[] dividirLlave(String aux){ String[] div=new String[8]; int pos=0,ini=0; for(int i=0;i<aux.length();i++){ if(aux.charAt(i)==' '){ div[pos++]=aux.substring(ini,i);


74

ini=i+1; }else if(i+1==aux.length()) div[pos++]=aux.substring(ini,i+1); } return div; } } Contenedor.java /* * Contenedor.java * * Created on April 13, 2007, 10:24 AM */ package AEspID; import java.io.File; /** * @author Abraham */ public class Contenedor { public InterfazPrincipal iPrin; public InterfazPropiedades iProp; public InterfazAlta iAlta; public InterfazAgregar iAgre; public InterfazFirma iFirm; public ManejadorDeCertificado aC_cert,usuario_cert; public ManejadorLlavesRSA aC_llaves,usuario_llaves; public File directorio; public Contenedor() { File cert = new File("AEspIDCertificado.cer"); iProp = new InterfazPropiedades(this); iFirm = new InterfazFirma(this); iAlta = new InterfazAlta(this); iAgre = new InterfazAgregar(this); iPrin = new InterfazPrincipal(this); this.aC_cert=new ManejadorDeCertificado(); this.usuario_cert=new ManejadorDeCertificado(); this.aC_llaves=new ManejadorLlavesRSA(); this.usuario_llaves=new ManejadorLlavesRSA();


75

if(cert.exists()) iPrin.setVisible(true); else iProp.setVisible(true); try { Class.forName("com.mysql.jdbc.Driver").newInstance(); } catch (IllegalAccessException ex) { ex.printStackTrace(); } catch (ClassNotFoundException ex) { ex.printStackTrace(); } catch (InstantiationException ex) { ex.printStackTrace(); } } public static void main(String []args){ Contenedor c=new Contenedor(); } } InterfazFirma.java /* * InterfazFirma.java * */ package AEspID; import java.io.*; import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; import java.security.Signature; import java.security.SignatureException; import javax.swing.DefaultListModel; import javax.swing.JFileChooser; import javax.swing.filechooser.FileFilter; import javax.swing.filechooser.FileNameExtensionFilter; /** * @author Juan Diego */ public class InterfazFirma extends javax.swing.JFrame {


76

public Contenedor c; private DefaultListModel listModel; File file; public InterfazFirma(Contenedor aux) { c=aux; initComponents(); listModel=new DefaultListModel(); FileFilter ff = new FileNameExtensionFilter("Archivos PDF", "pdf"); this.jFileChooser1.addChoosableFileFilter(ff); this.jFileChooser1.setFileSelectionMode(JFileChooser.FILES_ONLY); } // <editor-fold defaultstate="collapsed" desc=" Generated Code ">//GEN-BEGIN:initComponents private void initComponents() { jFileChooser1 = new javax.swing.JFileChooser(); jScrollPane1 = new javax.swing.JScrollPane(); jList1 = new javax.swing.JList(); jButton2 = new javax.swing.JButton(); jButton1 = new javax.swing.JButton(); jButton3 = new javax.swing.JButton(); jFileChooser1.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { jFileChooser1ActionPerformed(evt); } }); setTitle("Firmar Documentos"); addWindowListener(new java.awt.event.WindowAdapter() { public void windowClosing(java.awt.event.WindowEvent evt) { formWindowClosing(evt); } }); jScrollPane1.setViewportView(jList1); jButton2.setText("Firmar"); jButton2.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { jButton2ActionPerformed(evt); } }); jButton1.setText("Quitar"); jButton1.setEnabled(false); jButton1.addActionListener(new java.awt.event.ActionListener() {


77

public void actionPerformed(java.awt.event.ActionEvent evt) { jButton1ActionPerformed(evt); } }); jButton3.setText("Terminar"); jButton3.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { jButton3ActionPerformed(evt); } }); javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane()); getContentPane().setLayout(layout); layout.setHorizontalGroup( layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup() .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING, false) .addComponent(jButton2, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) .addComponent(jButton3, javax.swing.GroupLayout.Alignment.LEADING, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) .addComponent(jButton1, javax.swing.GroupLayout.Alignment.LEADING, javax.swing.GroupLayout.PREFERRED_SIZE, 90, javax.swing.GroupLayout.PREFERRED_SIZE)) .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) .addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 304, javax.swing.GroupLayout.PREFERRED_SIZE) .addContainerGap()) ); layout.setVerticalGroup( layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addGroup(layout.createSequentialGroup() .addContainerGap() .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) .addGroup(layout.createSequentialGroup() .addComponent(jButton2)


78

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) .addComponent(jButton1) .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) .addComponent(jButton3))) .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)) ); pack(); }// </editor-fold>//GEN-END:initComponents private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton3ActionPerformed // TODO add your handling code here: this.setVisible(false); c.iPrin.setVisible(true); limpiar(); }//GEN-LAST:event_jButton3ActionPerformed private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton1ActionPerformed // TODO add your handling code here: int del=jList1.getSelectedIndex(); String nombre=(String)listModel.get(del); File aux=new File(c.directorio.getPath()+"/"+nombre); aux.delete(); listModel.remove(del); jList1.setModel(listModel); if(listModel.getSize()==0) this.jButton1.setEnabled(false); }//GEN-LAST:event_jButton1ActionPerformed private void formWindowClosing(java.awt.event.WindowEvent evt) {//GEN-FIRST:event_formWindowClosing // TODO add your handling code here: this.setVisible(false); c.iPrin.setVisible(true); limpiar(); }//GEN-LAST:event_formWindowClosing private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton2ActionPerformed // TODO add your handling code here: int returnVal=jFileChooser1.showOpenDialog(InterfazFirma.this); if(returnVal==javax.swing.JFileChooser.APPROVE_OPTION){ file=jFileChooser1.getSelectedFile();


79

try { FileInputStream fis = new FileInputStream( file ); byte [] doc=new byte[fis.available()]; if(fis.read(doc)>0){ try { Signature sig=Signature.getInstance("SHA1withRSA"); sig.initVerify(c.usuario_llaves.getPublicKey()); sig.initSign(c.usuario_llaves.getPrivateKey()); sig.update(doc); File aux=new File(c.directorio.getPath()+"/"+quitarExt(jFileChooser1.getName(file))+".sig"); BufferedOutputStream salida = new BufferedOutputStream( new FileOutputStream(aux)); salida.write(sig.sign()); salida.close(); FileOutputStream fos = new FileOutputStream(c.directorio.getPath()+"/"+jFileChooser1.getName(file)); fos.write(doc); fos.close(); listModel.addElement(quitarExt(jFileChooser1.getName(file))+".sig"); jList1.setModel(listModel); this.jButton1.setEnabled(true); } catch (InvalidKeyException ex) { ex.printStackTrace(); } catch (NoSuchAlgorithmException ex) { ex.printStackTrace(); } catch (SignatureException ex) { ex.printStackTrace(); } catch (FileNotFoundException ex) { ex.printStackTrace(); } catch (IOException ex) { ex.printStackTrace(); } } fis.close(); } catch (FileNotFoundException ex) { ex.printStackTrace(); } catch (IOException ex) { ex.printStackTrace(); } } }//GEN-LAST:event_jButton2ActionPerformed private String quitarExt(String nombre){ int l=nombre.length(),i; char[] uno=nombre.toCharArray(); String salida="";


80

for(i=0;i<l&&uno[i]!='.';i++) salida=salida.concat(String.valueOf(uno[i])); return salida; } private void jFileChooser1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jFileChooser1ActionPerformed // TODO add your handling code here: }//GEN-LAST:event_jFileChooser1ActionPerformed private void limpiar(){ this.jButton1.setEnabled(false); this.listModel.clear(); this.jList1.setModel(listModel); } /** * @param args the command line arguments */ /*public static void main(String args[]) { java.awt.EventQueue.invokeLater(new Runnable() { public void run() { new InterfazFirma().setVisible(true); } }); }*/ // Variables declaration - do not modify//GEN-BEGIN:variables private javax.swing.JButton jButton1; private javax.swing.JButton jButton2; private javax.swing.JButton jButton3; private javax.swing.JFileChooser jFileChooser1; private javax.swing.JList jList1; private javax.swing.JScrollPane jScrollPane1; // End of variables declaration//GEN-END:variables } InterfazPrincipal.java /* * Interfazpincipal.java * */ package AEspID;


81

/** * @author Juan Diego */ public class InterfazPrincipal extends javax.swing.JFrame { public Contenedor c; /** Creates new form InterfazIntegracion */ public InterfazPrincipal(Contenedor aux) { c=aux; initComponents(); } // <editor-fold defaultstate="collapsed" desc=" Generated Code ">//GEN-BEGIN:initComponents private void initComponents() { jButton1 = new javax.swing.JButton(); jPasswordField1 = new javax.swing.JPasswordField(); jLabel1 = new javax.swing.JLabel(); jButton2 = new javax.swing.JButton(); jButton3 = new javax.swing.JButton(); jButton4 = new javax.swing.JButton(); jPasswordField2 = new javax.swing.JPasswordField(); jLabel2 = new javax.swing.JLabel(); jLabel3 = new javax.swing.JLabel(); setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE); setTitle("AEspID"); addWindowListener(new java.awt.event.WindowAdapter() { public void windowClosing(java.awt.event.WindowEvent evt) { formWindowClosing(evt); } }); jButton1.setText("Cargar Certificado y Llave Privada"); jButton1.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { jButton1ActionPerformed(evt); } }); jLabel1.setText("Clave de Autoridad"); jButton2.setText("Nuevo Usuario"); jButton2.setEnabled(false); jButton2.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) {


82

jButton2ActionPerformed(evt); } }); jButton3.setText("Agregar Documento"); jButton3.setEnabled(false); jButton3.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { jButton3ActionPerformed(evt); } }); jButton4.setText("Utilidades"); jButton4.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { jButton4ActionPerformed(evt); } }); jLabel2.setText("Clave de la BD"); jLabel3.setFont(new java.awt.Font("Nimbus Sans L Condensed", 1, 18)); jLabel3.setHorizontalAlignment(javax.swing.SwingConstants.CENTER); jLabel3.setText("Cargar Archivos de la AC..."); javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane()); getContentPane().setLayout(layout); layout.setHorizontalGroup( layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addGroup(layout.createSequentialGroup() .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addGroup(layout.createSequentialGroup() .addContainerGap() .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addGroup(layout.createSequentialGroup() .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addComponent(jLabel1) .addComponent(jLabel2, javax.swing.GroupLayout.PREFERRED_SIZE, 110, javax.swing.GroupLayout.PREFERRED_SIZE)) .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)


83

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false) .addComponent(jPasswordField1) .addComponent(jPasswordField2, javax.swing.GroupLayout.DEFAULT_SIZE, 155, Short.MAX_VALUE))) .addComponent(jLabel3, javax.swing.GroupLayout.DEFAULT_SIZE, 286, Short.MAX_VALUE))) .addGroup(layout.createSequentialGroup() .addGap(30, 30, 30) .addComponent(jButton1)) .addGroup(layout.createSequentialGroup() .addContainerGap() .addComponent(jButton2)) .addGroup(layout.createSequentialGroup() .addContainerGap() .addComponent(jButton3)) .addGroup(layout.createSequentialGroup() .addContainerGap() .addComponent(jButton4))) .addContainerGap()) ); layout.setVerticalGroup( layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addGroup(layout.createSequentialGroup() .addContainerGap() .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE) .addComponent(jLabel2) .addComponent(jPasswordField2, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) .addGap(11, 11, 11) .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE) .addComponent(jLabel1) .addComponent(jPasswordField1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) .addGap(16, 16, 16) .addComponent(jButton1) .addGap(21, 21, 21) .addComponent(jLabel3, javax.swing.GroupLayout.PREFERRED_SIZE, 17, javax.swing.GroupLayout.PREFERRED_SIZE) .addGap(18, 18, 18)


84

.addComponent(jButton2) .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) .addComponent(jButton3) .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) .addComponent(jButton4) .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)) ); pack(); }// </editor-fold>//GEN-END:initComponents private void jButton4ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton4ActionPerformed // TODO add your handling code here: this.setVisible(false); c.iProp.setVisible(true); }//GEN-LAST:event_jButton4ActionPerformed private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton3ActionPerformed // TODO add your handling code here: this.setVisible(false); c.iAgre.setVisible(true); }//GEN-LAST:event_jButton3ActionPerformed private void formWindowClosing(java.awt.event.WindowEvent evt) {//GEN-FIRST:event_formWindowClosing // TODO add your handling code here: }//GEN-LAST:event_formWindowClosing private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton2ActionPerformed // TODO add your handling code here: c.iAlta.setVisible(true); this.setVisible(false); }//GEN-LAST:event_jButton2ActionPerformed private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton1ActionPerformed // TODO add your handling code here String pass = String.copyValueOf(jPasswordField1.getPassword()); String passBD = String.copyValueOf(jPasswordField2.getPassword()); int estadoCert = c.aC_cert.importar("AEspIDCertificado.cer"); int estadoLlaves;


85

if(estadoCert==0){ //System.out.println(c.aC_cert.getX509Certificate().toString()); estadoLlaves = c.aC_llaves.importarLlavesConPivadaProtegida(pass, passBD,c.aC_cert.getPublicKey()); switch(estadoLlaves){ case 0: jLabel3.setText("Llave y Certificado Cargado!!"); this.jPasswordField1.setText(""); this.jPasswordField2.setText(""); jButton2.setEnabled(true); jButton3.setEnabled(true); break; case 1: jLabel3.setText("Error al acceder a la BD"); break; case 2: jLabel3.setText("Error al interpretar la llave Privada"); break; case 3: jLabel3.setText("Error al desencriptar la llave Privada"); break; case 4: jLabel3.setText("Error al importar el fromato de las Llaves"); break; } }else switch(estadoCert){ case 1: jLabel3.setText("Error al cargar el Certificado"); break; case 2: jLabel3.setText("No existe certificado de AC"); break; } }//GEN-LAST:event_jButton1ActionPerformed private javax.swing.JButton jButton1; private javax.swing.JButton jButton2; private javax.swing.JButton jButton3; private javax.swing.JButton jButton4; private javax.swing.JLabel jLabel1; private javax.swing.JLabel jLabel2; private javax.swing.JLabel jLabel3; private javax.swing.JPasswordField jPasswordField1; private javax.swing.JPasswordField jPasswordField2; }


86

RSAUtils.java package AEspID; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.BufferedReader; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.math.BigInteger; import java.security.SecureRandom; import org.bouncycastle.crypto.AsymmetricBlockCipher; import org.bouncycastle.crypto.AsymmetricCipherKeyPair; import org.bouncycastle.crypto.DataLengthException; import org.bouncycastle.crypto.digests.SHA512Digest; import org.bouncycastle.crypto.encodings.OAEPEncoding; import org.bouncycastle.crypto.encodings.PKCS1Encoding; import org.bouncycastle.crypto.engines.DESEngine; import org.bouncycastle.crypto.engines.RSAEngine; import org.bouncycastle.crypto.generators.RSAKeyPairGenerator; import org.bouncycastle.crypto.params.RSAKeyGenerationParameters; import org.bouncycastle.crypto.params.RSAKeyParameters; import org.bouncycastle.crypto.params.RSAPrivateCrtKeyParameters; import org.bouncycastle.util.encoders.Hex; //import org.dev2dev.security.crypto.blockcipher.BlockCipherTool; /** */ /** * RSAå·¥å…·ç±» * @author david.turing * @copyright GuangZhou BEA Usergroup * @version 0.7 * @modifyTime 22:30:34 */ public class RSAUtils { int keylength = 1024 ; int certainty = 20 ; RSAKeyGenerationParameters keyparam;


87

AsymmetricBlockCipher eng = null ; RSAKeyPairGenerator pGen = null ; AsymmetricCipherKeyPair pair = null ; public RSAUtils(){} public String getName(){ return " RSA " ; } public void setKeyLength( int rsakeylength){ if (rsakeylength == 512 || rsakeylength == 768 || rsakeylength == 1024 || rsakeylength == 2048 ) keylength = rsakeylength; } public void setCertaintyOfPrime( int certaintyofprime){ certainty = certaintyofprime; } public void initRSAKeyPair(){ RSAKeyGenerationParameters rsaparam = new RSAKeyGenerationParameters(BigInteger.valueOf( 0x3 ), new SecureRandom(), this .keylength, this .certainty); this .keyparam = rsaparam; RSAKeyPairGenerator pGen = new RSAKeyPairGenerator(); pGen.init(keyparam); pair = pGen.generateKeyPair(); pair.getPublic(); } public void setRSAKeyPair(RSAKeyParameters pubparam, RSAPrivateCrtKeyParameters privparam){ AsymmetricCipherKeyPair newpair = new AsymmetricCipherKeyPair(pubparam,privparam); pair = newpair; } public RSAKeyParameters getPublicKey(){ return (RSAKeyParameters)pair.getPublic(); } public RSAPrivateCrtKeyParameters getPrivateKey(){ return (RSAPrivateCrtKeyParameters)pair.getPrivate(); }


88

public void setRSAMode( int mode){ if (mode == 2 ) eng = new PKCS1Encoding(new RSAEngine()); else eng = new OAEPEncoding(new RSAEngine()); // mode==3 } } BlockCipherTool.java /** * @author david.turing * @blog: security.blogjava.net * @copyright GuangZhou BEA Usergroup * @version 0.7 */ package AEspID; import java.io.BufferedReader; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import org.bouncycastle.crypto.BlockCipher; import org.bouncycastle.crypto.CryptoException; import org.bouncycastle.crypto.DataLengthException; import org.bouncycastle.crypto.InvalidCipherTextException; import org.bouncycastle.crypto.modes.CBCBlockCipher; import org.bouncycastle.crypto.paddings.PaddedBufferedBlockCipher; import org.bouncycastle.crypto.params.KeyParameter; import org.bouncycastle.util.encoders.Hex; public class BlockCipherTool { private PaddedBufferedBlockCipher cipher = null; private int keylength; public void setEngine( BlockCipher block_cipher_engine){ /* * Setup the DESede cipher engine, create a PaddedBufferedBlockCipher * in CBC mode. */ cipher = new PaddedBufferedBlockCipher( new CBCBlockCipher(block_cipher_engine)); }


89

public void setKeyLength(int length){ this.keylength= length; } public void init(boolean encrypt,String keyStr){ byte[] keybyte=new byte[this.keylength]; keybyte=Hex.decode(keyStr); cipher.init(encrypt, new KeyParameter(keybyte)); } public boolean Encrypt(InputStream inputstream,OutputStream outputstream){ int inBlockSize = cipher.getBlockSize() * 10; int outBlockSize = cipher.getOutputSize(inBlockSize); byte[] inblock = new byte[inBlockSize]; byte[] outblock = new byte[outBlockSize]; int inL; int outL; byte[] rv = null; try { while ((inL=inputstream.read(inblock, 0, inBlockSize)) > 0){ outL = cipher.processBytes(inblock, 0, inL, outblock, 0); /* * Before we write anything out, we need to make sure * that we've got something to write out. */ if (outL > 0){ rv = Hex.encode(outblock, 0, outL); outputstream.write(rv, 0, rv.length); outputstream.write('\n'); } } try{ /* * Now, process the bytes that are still buffered * within the cipher. */ outL = cipher.doFinal(outblock, 0); if (outL > 0){ rv = Hex.encode(outblock, 0, outL); outputstream.write(rv, 0, rv.length);


90

outputstream.write('\n'); } } catch (CryptoException ce){ return false; } } catch (DataLengthException e) { return false; } catch (IllegalStateException e) { return false; } catch(Exception e){ return false; } return true; } /** * @param input * @param Key * @return */ public boolean Decrypt(InputStream inputstream,OutputStream outputstream){ BufferedReader br = new BufferedReader(new InputStreamReader(inputstream)); byte[] inblock = null; byte[] outblock = null; int outL; String rv = null; try { while ((rv = br.readLine()) != null){ inblock = Hex.decode(rv); outblock = new byte[cipher.getOutputSize(inblock.length)]; outL = cipher.processBytes(inblock, 0, inblock.length, outblock, 0); /* * Before we write anything out, we need to make sure * that we've got something to write out. */ if (outL > 0){ outputstream.write(outblock, 0, outL); } } try{


91

outL = cipher.doFinal(outblock, 0); if (outL > 0){ outputstream.write(outblock, 0, outL); } }catch(InvalidCipherTextException e){ return false; }catch (CryptoException ce){ return false; } } catch (DataLengthException e) { return false; } catch (IllegalStateException e) { return false; }catch(Exception e){ //System.exit( 1 ); return false; } return true; } }

Arquitectura Estándar para Identificación Digital Anexo II

92

ANEXO 2. CÓDIGO MÓDULO DE VERIFICACION E INTERPRETACION /** * @(#)Verificar.java * * Verificar Applet application * * @author Guadalupe * @version 1.00 */ import java.io.*; import java.awt.*; import java.awt.Font; import java.awt.event.*; import java.net.*; import java.net.UnknownServiceException; import java.applet.*; import java.util.Date; import java.util.Vector; import java.text.SimpleDateFormat; import java.security.cert.*; import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; import java.security.NoSuchProviderException; import java.security.Signature; import java.security.SignatureException; import javax.swing.*; import javax.swing.event.*; import javax.media.jai.Interpolation; import javax.media.jai.JAI; import javax.media.jai.RenderedOp; import javax.swing.DefaultListModel; import java.awt.image.renderable.ParameterBlock; import com.adobe.acrobat.*; public class Verificar extends JApplet { private String cert_a; private String cert_u; private String documentos[]; private String firmas[]; private String path; private String valor; private Date fecha; private int corrupto; private boolean con_ser;


93

//certificados private X509Certificate cert,certCA,result; /* * cert contendra el certificado del usuario * certCA contendra el certificado de la Autoridad Certificadora */ //elementos graficos private JComboBox jComboBox1; private JTextArea info; private JTextArea info2; private JLayeredPane jLayeredPane1; private JLayeredPane jLayeredPane2; private JLayeredPane jLayeredPane3; private JLayeredPane jLayeredPane4; private JLayeredPane jLayeredPane5; private JLayeredPane jLayeredPane6; private JLayeredPane jLayeredPane7; private JLayeredPane jLayeredPane8; private JScrollPane infoscroll; private JScrollPane info2scroll; private JButton boton1; private JButton boton2; private JLabel etiqueta1, etiqueta2, etiqueta3; private DefaultListModel listModel; private JScrollPane jsp; private RenderedOp image,zoom; private Vector v, archivos, firma; private Viewer viewer; private int mem; private int cer_cargado; private int cerval; public void init(){ String parametro = null; int i=0, respuesta=0; int valido =0; cerval = 0; corrupto =0; cer_cargado=0; con_ser = false; //obtenemos el path de donde se corrio la aplicacion parametro = getParameter("path");


94

//formateamos el parametro para que sea una direccion valida obtenerParametro(parametro); Date f = getFechaServidor(); cargarCertificado(); initVisualizacion(); iniciarValidacion(); } public void obtenerParametro(String parametro){ if(parametro==null) path = null; else if(parametro!=null){ int posfin = parametro.indexOf("index.html"); int posini = 0; String param = null; //si la direccion comienza con una '/' comenzamos a leer en la posicion 1 if(parametro.startsWith("/")) posini=1; //obtenemos la subcadena if(posfin!=-1) param = parametro.substring(posini,posfin); path=param; } } public void iniciarValidacion(){ String mensaje = new String(); String status = new String(); int leer, cert=0; if(path!=null){ cert = obtenerCertificados(); if(cert==2){ mensaje = info.getText(); cert_u = null; path = null; } else{ if(cert==0){ mensaje = "\n\n EL directorio no contiene ningun certificado."; cert_u = null; path = null; } }


95

initVisualizacion(); if(cert_u!=null){ obtenerDocumentos(); //Se obtiene un arreglo con las firmas de los documentos obtenerFirmas(); initVisualizacion(); leer = readerPEMCertificate(path+cert_u,false); if(leer==1){ //obtener el numero de serie del certificado de usuario valor=obtenerSerie(); //verifica si el cerfificado del usuario es valido if(verificarCertificado()){ if(cer_cargado==0){ mostrarMensaje(" El Certificado es valido",3,etiqueta2); cerval = 1; } else{ jComboBox1.removeAllItems(); JOptionPane.showMessageDialog(null,"No se pudo establecer la conexion con el servidor"); mostrarMensaje(" No se ha podido verificar el certificado",1,etiqueta2); } //verifica si el certificado ha expirado if(!expirado()){ //si el certificado no ha sido revocado if(!revocado()){ mostrarMensaje(" Informacion del Certificado",2,etiqueta3); status = getInfoCertificado(); } else{ jComboBox1.removeAllItems(); mostrarMensaje("\tEl Certificado ha sido revocado",1,etiqueta2); } } //if expirado else{ jComboBox1.removeAllItems(); mostrarMensaje("\tEl Certificado ha expirado",1,etiqueta2); } }// if verificarCertificado else{ cerval = 0; mostrarMensaje("\tEl Certificado no es valido",1,etiqueta2);


96

jComboBox1.removeAllItems(); mensaje = "\n\nEL certificado no es valido, \neste certificado no ha sido creado por la\nAC AEspID"; } mensaje += status; } else if(leer==2){ mostrarMensaje("ERROR EN EL CERTIFICADO",1,etiqueta1); mensaje = "Ha ocurrido un error mientras se leia el certificado. \n\nEl certificado ha sido modificado"; corrupto =1; jComboBox1.removeAllItems(); info2.setText("\n\n NO SE HAN CARGADO LOS DOCUMENTOS"); } } //if cert_u else mostrarMensaje("Seleccione un directorio valido",1,etiqueta1); } else mostrarMensaje("Seleccione el directorio donde se encuentra el certificado",1,etiqueta1); info.setText(mensaje); } public void mostrarMensaje(String msg, int tipo, JLabel la){ switch(tipo){ case 1: la.setForeground(Color.RED); break; case 2: la.setForeground(Color.BLUE); break; case 3: Color col = new Color(95,159,83); la.setForeground(col); break; } la.setText(msg); } //valida si el certificado no ha expirado public boolean expirado(){ boolean resp=false;


97

//obtenemos la fecha actual System.out.println(con_ser); if(con_ser){ System.out.println("fecha del servidor"); fecha = getFechaServidor(); } else{ System.out.println("fecha del cliente"); fecha = new Date(); } System.out.println(fecha.toString()); try{ cert.checkValidity(fecha); }catch(CertificateExpiredException e){ resp=true; }catch(CertificateNotYetValidException e){ resp=true; } return resp; } public String formatearFecha(Date fecha){ SimpleDateFormat formato = new SimpleDateFormat("EEE, d MMM yyyy HH:mm:ss"); return formato.format(fecha); } public String formatearInfo(String nombre){ int pos = 0; String firma = new String(); pos = nombre.indexOf("CN="); return nombre.substring(pos+3); } public String getInfoCertificado(){ String estado = new String(); estado = "\nEmitido a:\t" + formatearInfo(cert.getSubjectDN().getName()); estado += "\n\nEmitido por:\t" + formatearInfo(cert.getIssuerDN().getName()); estado += "\n\nValido desde:\t" + formatearFecha(cert.getNotBefore()); estado += "\n\nValido hasta:\t" + formatearFecha(cert.getNotAfter());


98

return estado; } public void initVector(){ int i,con; if(path!=null){ con = documentos.length; File imagen; v = new Vector(con); for(i=0;i<con;i++){ imagen = new File(path+documentos[i]); v.add(imagen); } } } public void cargaCombo(){ for(int i=0;i<archivos.capacity();i++) jComboBox1.addItem(((File)archivos.get(i)).getName()); } public void inicializarVisor(String archivo){ try{ if(archivo!=null){ InputStream input = new FileInputStream(new File(path+archivo)); viewer.setDocumentInputStream(input); viewer.setEnableDebug(true); viewer.setProperty("Default_Page_Layout", "SinglePage"); viewer.setProperty("Default_Zoom_Type", "FitPage"); viewer.setProperty("Default_Magnification", "100"); //zoom del documento viewer.zoomTo(1.0); viewer.activate(); //borramos todo del contenido del panel jLayeredPane8.removeAll(); //se agrega el visor al panel para que se recargue con el pdf jLayeredPane8.add(BorderLayout.CENTER,viewer); } } catch(Exception e){ e.printStackTrace(); }


99

} //funcion que inicializa las etiquetas del applet public void inicializarEtiquetas(){ etiqueta1.setFont(new Font("Sans Serif", Font.TRUETYPE_FONT,14)); etiqueta1.setHorizontalAlignment(SwingConstants.CENTER); etiqueta2.setFont(new Font("Serif", Font.TRUETYPE_FONT,14)); etiqueta3.setFont(new Font("Serif", Font.TRUETYPE_FONT,14)); /*si el path es nulo mostrar mensaje, para seleccionar la ruta de donde se encuentra el certificado*/ if(path==null){ etiqueta1.setForeground(Color.RED); etiqueta1.setText("Selecciona el directorio donde se encuentra el Certificado"); } else{ etiqueta1.setForeground(Color.BLUE); etiqueta1.setText("ESTADO DEL CERTIFICADO"); } } public void inicializarText(){ info.setFont(new Font("Sans Serif",Font.PLAIN,13)); info.setForeground(Color.BLACK); info.setColumns(30); info.setRows(20); info.setEditable(false); info2.setRows(5); info2.setEditable(false); //se agregan scroll a los text area, para mostar todo el contenido infoscroll = new JScrollPane(info, infoscroll.VERTICAL_SCROLLBAR_ALWAYS, infoscroll.HORIZONTAL_SCROLLBAR_AS_NEEDED ); info2scroll = new JScrollPane(info2, info2scroll.VERTICAL_SCROLLBAR_ALWAYS, info2scroll.HORIZONTAL_SCROLLBAR_AS_NEEDED ); } /* inicializa el comboBox con los nombres de los archivos encontrados dentro de la ruta */ public void inicializarCombo(){ if(path!=null && archivos!=null){ for(int i=0;i<archivos.capacity();i++) jComboBox1.addItem(((File)archivos.get(i)).getName());


100

} jComboBox1.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent evt) { jComboBox1ActionPerformed(evt); } }); } public void inicializarBotones(){ boton1.setText("Abrir"); boton2.setText("Limpiar"); boton1.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent evento){ abrirDirectorio(); } }); } /* se agregan los botones al panel */ public void agregarBotones(){ int rows = 1; /* si no existe el path, se agrega el boton de abrir para selecionar el directorio * donde se encuentra el certificado */ if(path==null){ jLayeredPane6.setLayout(new GridLayout(rows,1)); jLayeredPane6.add(boton1); rows = 2; } } /* Se inicializan todos los componentes del applet */ public void initVisualizacion(){ try{ listModel = new DefaultListModel(); jComboBox1 = new JComboBox(); info = new JTextArea(); info2 = new JTextArea(); boton1 = new JButton(); boton2 = new JButton(); etiqueta1 = new JLabel(); etiqueta2 = new JLabel(); etiqueta3 = new JLabel(); viewer = new Viewer();


101

//Paneles jLayeredPane1 = new JLayeredPane(); jLayeredPane2 = new JLayeredPane(); jLayeredPane3 = new JLayeredPane(); jLayeredPane4 = new JLayeredPane(); jLayeredPane5 = new JLayeredPane(); jLayeredPane6 = new JLayeredPane(); jLayeredPane7 = new JLayeredPane(); jLayeredPane8 = new JLayeredPane(); inicializarEtiquetas(); inicializarText(); inicializarCombo(); inicializarBotones(); setLayout(new java.awt.BorderLayout()); jLayeredPane2.setLayout(new GridLayout(1,1)); jLayeredPane2.add(jComboBox1); jLayeredPane5.setLayout(new BorderLayout()); jLayeredPane5.add(BorderLayout.CENTER,jLayeredPane2); jLayeredPane5.add(BorderLayout.SOUTH,info2scroll); agregarBotones(); jLayeredPane7.setLayout(new GridLayout(3,1,10,10)); jLayeredPane7.add(etiqueta1); jLayeredPane7.add(etiqueta2); jLayeredPane7.add(etiqueta3); jLayeredPane3.setLayout(new BorderLayout()); jLayeredPane3.add(BorderLayout.NORTH,jLayeredPane7); jLayeredPane3.add(BorderLayout.CENTER,infoscroll); jLayeredPane1.setLayout(new BorderLayout()); jLayeredPane8.setLayout(new BorderLayout()); jLayeredPane8.add(BorderLayout.CENTER,viewer); jLayeredPane1.add(BorderLayout.CENTER,jLayeredPane8); inicializarVisor(null); jLayeredPane1.add(BorderLayout.SOUTH,jLayeredPane5); jLayeredPane4.setLayout(new BorderLayout()); jLayeredPane4.add(BorderLayout.CENTER,jLayeredPane3); jLayeredPane4.add(BorderLayout.SOUTH,jLayeredPane6);


102

add(BorderLayout.CENTER,jLayeredPane1); add(BorderLayout.WEST,jLayeredPane4); mem=100; }catch(Exception e){ e.printStackTrace(); } } public void abrirDirectorio(){ JFileChooser selectorDir = new JFileChooser(); selectorDir.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY); int resultado = selectorDir.showSaveDialog(this); //si se presiono el boton cancelar if(resultado == JFileChooser.CANCEL_OPTION) return; path = selectorDir.getSelectedFile().getAbsolutePath(); path += "\\"; jLayeredPane1.removeAll(); jLayeredPane4.removeAll(); iniciarValidacion(); } public void jComboBox1ActionPerformed(ActionEvent evt){ String nombre, dir; String firma = new String(); String texto; int pos = jComboBox1.getSelectedIndex(); int valido = 0; if(pos!=-1){ nombre = jComboBox1.getItemAt(pos).toString(); dir = ((File)archivos.get(pos)).getPath(); inicializarVisor(nombre); info2.setText(""); firma = getFirma(nombre); texto = info2.getText(); valido = verificarFirmas(dir,firma); if(valido==1)


103

texto += "\n\nEl documento es valido"; else{ if(valido==2) texto += "\n\nEl documento no es valido"; else texto += "\n\nEl documento no esta firmado"; } info2.setText(texto); } else info2.setText("\n\nSelecciona un archivo"); } public String getFirma(String archivo){ int pos = 0; int posfirma = 0; int con = 0, i=0; String nombre = new String(); String firm = new String(); if(archivo.indexOf(".pdf")!=-1) pos = archivo.indexOf(".pdf"); else{ if(archivo.indexOf(".PDF")!=-1) pos = archivo.indexOf(".PDF"); } con = firmas.length; nombre = archivo.substring(0,pos); for(i=0;i<con;i++){ if(firmas[i].compareTo(nombre)==0){ firm = ((File)firma.get(i)).getPath(); break; } } return firm; } public int obtenerCertificados(){ int i=0,con; int total = 0; File raiz = new File(this.path); String [] ficheros = raiz.list(new Filtro(".cer")); String mensaje = new String(); total = ficheros.length;


104

if(total>1){ JOptionPane.showMessageDialog(null,"Hay mas de un certificado en el directorio"); mensaje = "\nEl directorio solo debe contener un certificado de usuario."; mensaje += "\n\nSe encontraron los siguientes certificados: \n\n"; for(i=0;i<ficheros.length;i++) mensaje += " - "+ficheros[i]+"\n"; mensaje += "\nPresione el boton 'Abrir' para selecionar otro directorio"; info.setText(mensaje); return 2; } else{ if(total==0) return total; else{ cert_u = ficheros[0]; return 1; } } } public void obtenerDocumentos(){ int i=0,con=0; int total; File raiz = new File(this.path); //obtenemos los archivos con extension '.pdf' String [] ficheros = raiz.list(new Filtro(".pdf")); String [] ficheros2 = raiz.list(new Filtro(".PDF")); //obtenemos el total de archivos encontrados total = ficheros.length+ficheros2.length; String [] files = new String[total]; for(i=0;i<ficheros.length;i++,con++) files[i] = ficheros[i]; for(i=0;i<ficheros2.length;i++,con++) files[con] = ficheros2[i]; if(path!=null){ File documento; //se crea un vector para almacenar los nombres de los archivos archivos = new Vector(total); for(i=0;i<files.length;i++){ documento = new File(path+files[i]); archivos.add(documento);


105

} } } public void obtenerFirmas(){ int i=0,con; File raiz = new File(this.path); String nombre; String [] ficheros = raiz.list(new Filtro("sig")); if(path!=null){ File documento; //se crea un vector para almacenar las firmas de los documentos firma = new Vector(ficheros.length); for(i=0;i<ficheros.length;i++){ documento = new File(path+ficheros[i]); firma.add(documento); } firmas = new String[firma.capacity()]; //guarda el nombre de las firmas en un arreglo, quitando la extension '.sig' for(i=0;i<firma.capacity();i++){ nombre = ((File)firma.get(i)).getName(); firmas[i] = nombre.substring(0,nombre.indexOf(".sig")); } } } public int verificarFirmas(String documento, String firm){ int valido=0; try { //lee la firma del documento BufferedInputStream entrada = new BufferedInputStream( new FileInputStream(firm)); //lee el documento BufferedInputStream archivo = new BufferedInputStream( new FileInputStream(documento)); Signature sig=Signature.getInstance("SHA1withRSA"); sig.initVerify(cert.getPublicKey()); byte[] bytesArchivo=new byte[archivo.available()]; archivo.read(bytesArchivo); sig.update(bytesArchivo); byte[] bytesFirma=new byte[entrada.available()];


106

entrada.read(bytesFirma); //verificamos si la firma es valida if(sig.verify(bytesFirma)){ valido = 1; } else{ valido = 2; } entrada.close(); archivo.close(); }catch (InvalidKeyException ex) { ex.printStackTrace(); }catch (SignatureException ex) { ex.printStackTrace(); }catch (FileNotFoundException ex) { //Si no existe la firma valido=3; }catch (NoSuchAlgorithmException ex) { ex.printStackTrace(); }catch (IOException ex) { ex.printStackTrace(); } return valido; } public boolean verificarCertificado() { boolean estado=true; cargarCertificado(); try { cert.verify(certCA.getPublicKey()); }catch (InvalidKeyException ex) { ex.printStackTrace(); estado=false; }catch(SignatureException ex){ ex.printStackTrace(); estado=false; }catch (Exception ex) { ex.printStackTrace(); estado=false; } return estado; } //leer los certificados, tanto del usuario como de la CA


107

public int readerPEMCertificate(String certFile,boolean ca){ int estado = 1; try { FileInputStream fis = new FileInputStream(certFile); BufferedInputStream bis = new BufferedInputStream(fis); CertificateFactory cf = CertificateFactory.getInstance("X.509"); while (bis.available() > 0) { Certificate certAux = cf.generateCertificate(bis); if(ca){ certCA=(X509Certificate)certAux; } else{ cert=(X509Certificate)certAux; } } }catch (CertificateException ex) { ex.printStackTrace(); estado = 2; }catch (FileNotFoundException ex) { ex.printStackTrace(); }catch (IOException ex) { ex.printStackTrace(); } return estado; } //extrae el numero de serie del certificado de usuario public String obtenerSerie(){ return (cert.getSerialNumber().toString()); } public URLConnection getServletConnection() throws MalformedURLException, IOException { // Conexion URL urlServlet = new URL(getCodeBase(), "verificarCertificado"); URLConnection con = urlServlet.openConnection(); // configuracion con.setDoInput(true); con.setDoOutput(true); con.setUseCaches(false); con.setRequestProperty("Content-Type","application/x-java-serialized-object"); return con;


108

} private URLConnection conectarServletValidar() throws MalformedURLException, IOException { // Conexion URL urlServlet = new URL(getCodeBase(), "validarCertificado"); URLConnection con = urlServlet.openConnection(); // configuracion con.setDoInput(true); con.setDoOutput(true); con.setUseCaches(false); con.setRequestProperty("Content-Type","application/x-java-serialized-object"); return con; } private URLConnection conectarServletPedir() throws MalformedURLException, IOException { // Conexion URL urlServlet = new URL(getCodeBase(), "enviarCertificado"); URLConnection con = urlServlet.openConnection(); // configuracion con.setDoInput(true); con.setDoOutput(true); con.setUseCaches(false); con.setRequestProperty("Content-Type","application/x-www-form-urlencoded"); return con; } private URLConnection servletFecha() throws MalformedURLException, IOException { // Conexion URL urlServlet = new URL(getCodeBase(), "fechaServidor"); URLConnection con = urlServlet.openConnection(); // configuracion con.setDoInput(true); con.setDoOutput(true); con.setUseCaches(false); con.setRequestProperty("Content-Type","application/x-java-serialized-object");


109

return con; } //verifica si el certificado ha sido revocado public boolean revocado() { int respuesta=0; boolean revocado = false; try { URLConnection con = getServletConnection(); OutputStream outstream = con.getOutputStream(); ObjectOutputStream salida = new ObjectOutputStream(outstream); salida.writeObject(valor); salida.flush(); salida.close(); //recibe el resultado del servlet InputStream entrada = con.getInputStream(); ObjectInputStream inputFromServlet = new ObjectInputStream(entrada); String result = (String) inputFromServlet.readObject(); respuesta = Integer.parseInt(result); inputFromServlet.close(); entrada.close(); if(respuesta==1) revocado = true; else revocado = false; }catch(Exception ex) { ex.printStackTrace(); } return revocado; } public Date getFechaServidor(){ try { // enviamos el numero de serie al servlet URLConnection con = servletFecha(); OutputStream outstream = con.getOutputStream(); ObjectOutputStream salida = new ObjectOutputStream(outstream); salida.writeObject(valor); salida.flush(); salida.close(); //recibimos el resultado del servlet InputStream entrada = con.getInputStream(); ObjectInputStream inputFromServlet = new ObjectInputStream(entrada);


110

Date fechaSer = (Date)inputFromServlet.readObject(); inputFromServlet.close(); entrada.close(); con_ser = true; return fechaSer; }catch(UnknownServiceException ex){ ex.printStackTrace(); con_ser = false; }catch(Exception ex){ con_ser = false; ex.printStackTrace(); } return (new Date()); } private void cargarCertificado() { try { // enviamos una cadena al servlet URLConnection con = conectarServletPedir(); OutputStream outstream = con.getOutputStream(); ObjectOutputStream salida = new ObjectOutputStream(outstream); salida.writeObject("AEspIDCertificado.cer"); salida.flush(); salida.close(); //recibimos el certificado de la Autoridad Certificadora (AC) InputStream entrada = con.getInputStream(); CertificateFactory cf = CertificateFactory.getInstance("X.509"); if(entrada.available() > 0) { Certificate certAux = cf.generateCertificate(entrada); certCA=(X509Certificate)certAux; } entrada.close(); }catch (Exception ex){ ex.printStackTrace(); } } }//fin de la clase

Arquitectura Estándar para Identificación Digital Anexo III

111

ANEXO 3. CÓDIGO MÓDULO DE SERVICIOS <%@ page import = "java.sql.*"%> <% String url="jdbc:mysql://localhost:3306/AEspIDDB"; Connection conn; Statement stmt; ResultSet rs; Class.forName( "com.mysql.jdbc.Driver").newInstance(); conn = DriverManager.getConnection(url,"root","aespidmysql"); stmt = conn.createStatement(); %> <html> <head> <title>Arquitectura Estandar para Identificación Digital.</title> <script language="javascript" src="js/aespid.js"></script> <link rel=stylesheet href="css/aespid.css"> </head> <body background="img/fondo1.jpg" bgproperties="fixed"> <jsp:useBean id='form' class='beans.Form' scope='request'> <jsp:setProperty name='form' property='*'/> </jsp:useBean> <br><br><br> <center><h1>Arquitectura Estandar para Identificación Digital.</h1> <br><br><br><br> <form name="menu_p" method=POST> <input type="hidden" name="opcion"> <% String i = form.getOpcion(); String nombre = form.getName(); String paswd = form.getPaswd(); if(i.compareTo("1") != 0 && i.compareTo("2") != 0){ out.println("<div class=menu onclick=\"javascript:menu_opcion(1);\">Información general.</div>"); out.println("<br><br><br>"); out.println("<div class=menu onclick=\"javascript:menu_opcion(2);\">Certificados revocados.</div>"); out.println("<br><br><br>"); } else if(i.compareTo("1")==0) { out.println("<h2>Información del proyecto</h2>");


112

out.println("<br><br>"); %> <table width=75%> <tr> <td> Dentro de cualquier sociedad humana la identidad de cada uno de sus integrantes es muy importante, debido a que ésta (la identidad) permitirá aplicar las leyes y beneficios comunes establecidos en cada sociedad. Sea una comunidad laboral, de educación, o de cualquier índole, no podemos olvidar la necesidad de identificar a cada uno de los participantes de estas comunidades. <br><br> Sabiendo que la identificación de personas es y será un tema de investigación y desarrollo importante ligado a la constante evolución de las sociedades humanas, el presente proyecto construye e implementa una arquitectura estándar para la identificación de personas a través de medios electrónicos. Es una propuesta que busca la creación de un sistema de identificación, el cual haga uso de las posibilidades tecnológicas actuales, y que por sus características pueda crear una identificación digital funcional. <br><br> <b>Este proyecto propone:</b> <ul> <li> La creación de una arquitectura estándar capaz de ser implementada fácilmente sin afectar el funcionamiento de sistemas de información ya existentes. <li> Que la arquitectura creada contemple la certificación de los usuarios que la solicitan, y brinde los servicios necesarios para gestionar dichas certificaciones. <li> Una entidad central encargada de la certificación de usuarios, de la creación de documentos respaldados por la entidad de mayor importancia dentro de la organización donde se implementa la arquitectura, y de proveer el software necesario para la interpretación y funcionamiento de la identificación digital creada. <li> Una serie de documentos electrónicos con firma digital que permitan al usuario facilitar su identificación dentro de la organización donde se encuentre implantada la arquitectura propuesta. <li> La utilización de dispositivos de almacenamiento portátiles para contener la identificación digital, principalmente el uso de memorias USB con capacidad de almacenamiento suficiente según se requiera en la identificación. <li>


113

La creación de aplicaciones capaces de conectarse a través de Internet con el servidor central para verificar la validez de la identificación en el momento de ser usada, además de brindar una interfaz de usuario sencilla y práctica para la interpretación de la identificación digital. </ul> <br><br> <b>Objetivo</b> <br><br> Construir e implementar una arquitectura estándar para la identificación de personas utilizando dispositivos de almacenamiento portátil, certificación de usuarios y documentos electrónicos con firma digital. <br><br> <font color=red>NOTA:</font> Para poder ver correctamente las identificaciones digitales es necesario tener instalado algun software especial en la máquina donde se mostrará. Listamos el softaware y el lugar donde puede ser descargado: <ul> <li><a href="https://sdlc1a.sun.com/ECom/EComActionServlet/DownloadPage:~:com.sun.sunit.sdlc.content.DownloadPageInfo;jsessionid=F165E0802808AF4D857A15F291895E7C;jsessionid=F165E0802808AF4D857A15F291895E7C">JRE</a> <li><a href="http://www.adobe.com/products/acrviewer/acrvdnld.html?name=Accept#win">Visor de documentos PDF.</a> </ul> </td> </tr> </table> <% out.println("<div class=menu onclick=\"javascript:menu_opcion(0);\"><img src=\"img/principal.gif\"></img> Menú Principal.</div>"); } else if(i.compareTo("2")==0) { out.println("<h2>Certificados revocados</h2>"); out.println("<br><br>"); out.println("En esta sección del sistema usted tiene la posibilidad de revocar su certificado."); out.println("<br><br>"); if(nombre.compareTo("") == 0){ out.println("<br><br>"); %> <table border=0 bordercolor=blue> <tr>


114

<td>Número de Serie:</td><td><input type='text' name='name' size=7></td> </tr> <tr> <td>Clave:</td><td><input type='password' name='paswd' size=7></td> </tr> </table> <br><br><div class=menu_l onclick="javascript:enviar();">Enviar.</div> <% } else { out.println("<br>Bienvenido <b>" + nombre + "</b><br>"); try{ rs=stmt.executeQuery("select * from usuarios where NumeroSerie = "+nombre); String clave=""; int nserie=0; rs.next(); clave=rs.getString(2); nserie=rs.getInt(1); if(clave.compareTo(paswd) == 0){ try { int n=stmt.executeUpdate("insert into LCR values(" + nserie + "); "); out.println("<b>Certificado Revocado.</b>"); } catch(SQLException e) {out.println("El siguiente error se generó en la base de datos:<br> "+e);}; } else out.println("<b>Contraseña incorrecta."); } catch(SQLException e) {out.println("Usuario aun no registrado en la base de datos.");}; } out.println("<div class=menu onclick=\"javascript:menu_opcion(0);\"><img src=\"img/principal.gif\"></img> Menú Principal.</div>"); } %> </form> </center> </body> </html>

“Arquitectura Estándar para Identificación...

Documents

Transcript of “Arquitectura Estándar para Identificación...