Embed Size (px)
Citation preview
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 1 de 32
Guía para la Integración de Trámites Electrónicos al SEITS
Versión 1.0
Dirección General del Sistema Estatal de Informática
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 2 de 32
Mayo de 2014
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 3 de 32
Contenido 0. Historia ...................................................................................................................................... 4
1. Introducción ........................................................................................................................... 5
1.1 Propósito ......................................................................................................................... 6
1.2 Alcance ............................................................................................................................. 6
1.3 Definiciones y acrónimos ........................................................................................... 7
2. Vista General .......................................................................................................................... 8
2.1. Suposiciones y Restricciones ................................................................................... 8
2.2. Diagrama general de componentes ....................................................................... 9
2.3. Componentes del SEITS ............................................................................................. 9
3. Definición técnica de los componentes de comunicación .................................. 13
3.1 Componente A: Comunicación SEITS a trámite ............................................. 13
3.2 Componente B: Servicio Web para actualización de estatus .................... 14
3.3 Componente C: URL para seguimiento o retroalimentación ..................... 16
4. Ejemplos ................................................................................................................................ 17
4.1 Ejemplo de la cadena encriptada, para desencriptarla y ver
siefectivamente está funcionando bien el código del trámite. ............................. 17
4.2 Ejemplo del código fuente en JAVA para desencriptar los parámetros.
17
4.3 Ejemplo de la URL para ingresar desde el SEITS y probar los cambios
realizados. ................................................................................................................................. 19
4.4 Ejemplo del código fuente en PHP para desencriptar los parámetros. . 19
4.5 Ejemplo del código fuente en PHP para consumir el servicio web. ........ 29
5. Referencias ........................................................................................................................... 31
5.1 Documentación en Internet .................................................................................... 31
5.2 Diagrama de Flujo ...................................................................................................... 31
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 4 de 32
0. Historia
FECHA VERSIÓN REALIZÓ DESCRIPCIÓN
14/05/2013 0.1 Adrián Miramar Ajuste en el envío de la
información al trámite
28/06/2013 0.2 Juvenal Fernández Ajuste en la descripción del
proceso
04/07/2013 0.3 Gustavo González Revisión del documento
05/03/2014 0.4 Jesús García Se agregó la sección de
ejemplos y se complementaron diversos apartados
05/03/2014 0.4 Edrel Medina Se ajustó la información
referente al RETYS
05/03/2014 0.4 Anastacio Damián Revisión del documento
06/05/2014 0.7 Gustavo González Revisión del documento
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 5 de 32
1. Introducción
En la actualidad la administración de los procesos que soportan los
servicios gubernamentales, es compleja, desarticulada y poco intuitiva y
por lo tanto difícil de entender para las personas que tienen la tarea de
utilizar, administrar y supervisar dichos procesos, lo que crea una brecha
de comunicación interinstitucional, ya que la información no se comparte
entre las diferentes unidades administrativas y niveles gubernamentales
(Municipal, Estatal y Federal).
Tratando de disminuir ésta brecha es cómo surge el concepto de SEITS
(Sistema Electrónico de Información, Trámites y Servicios del Estado de
México).
¿Qué es el SEITS?
Es una plataforma informática que será administrada y operada por la
Dirección General del Sistema Estatal de Informática y que tiene por
objeto hacer posible la gestión de trámites y servicios con base en los
medios electrónicos y sistemas de información, con la finalidad de
contribuir en la simplificación administrativa y a hacer más ágil y
eficiente la prestación del servicio público.
Entre los beneficios hacia los usuarios se considera tener un punto único
de acceso para:
Obtener información relacionada a todos los trámites y servicios que ofrece el Gobierno hacia el ciudadano.
Solicitar y gestionar electrónicamente un trámite o servicio de forma remota, reduciendo su asistencia a las oficinas de Gobierno y facilitando su consulta para conocer el avance de sus trámites, desde su atención hasta su conclusión.
Tener un expediente personal donde pueda dar seguimiento a sus trámites e interactuar de forma personalizada con las dependencias de Gobierno.
Acceder a los servicios las 24 horas del día, los 365 días del año.
Fácil acceso para el usuario
Disminuir las visitas a oficinas gubernamentales, obteniendo ahorro en tiempo y gastos.
Los beneficios para el Gobierno son los siguientes:
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 6 de 32
Mantener el control sobre las solicitudes y los tiempos de atención de las dependencias que prestan el servicio.
Ampliar la cobertura de los servicios a la sociedad mexiquense
Mayor transparencia en la prestación de los servicios al ciudadano y disminuir los niveles de corrupción.
Consultar estadísticas sobre el nivel de servicio de atención de los trámites, permitiendo tomar acciones para mejorar el servicio al ciudadano.
Proyectar un Gobierno que se acerca a la ciudadanía a través de herramientas para seguimiento de solicitudes de trámites y servicios.
Contar con una base de datos homologada de ciudadanos y sujetos de la ley.
Facilitar y habilitar la interoperabilidad entre las dependencias y organismos del Gobierno Estatal permitiendo el acceso a la base de datos homologada.
1.1 Propósito
La presente guía tiene como objetivo describir cómo usar los
componentes técnicos y los pasos necesarios para integrar un trámite o
servicio electrónico en ambiente web, con el sistema SEITS (Ventanilla
Electrónica Única).
Permite identificar los ajustes que deberán realizarse a la programación
de un trámite o servicio electrónico web para que sea ejecutado,
monitoreado en su avance e interactúe con el usuario final, hasta su
término o conclusión, a través del SEITS, como cara principal del trámite
o servicio hacia el ciudadano.
1.2 Alcance
Aplica para todos los Trámites y Servicios Electrónicos que por la Ley de
Uso de Medios Electrónicos están obligados a incorporarse al SEITS.
Para que un trámite o Servicio Electrónico se pueda integrar al SEITS,
deberá estar registrado en el sistema RETYS - Registro Estatal de
Trámites y Servicios.
A través del sistema SEITS el ciudadano podrá conocer el estado en que
se encuentra su trámite o servicio solicitado, así como será informado o
notificado de alguna situación específica con su petición, para
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 7 de 32
finalmente recibir la información o documentos solicitados a las distintas
dependencias y organismos del Gobierno.
1.3 Definiciones y acrónimos
Carpeta Ciudadana: Apartado en donde cada usuario del sistema SEITS tendrá acceso de forma privada, a través de su CUTS, para poder solicitar, consultar y recibir información de sus trámites y servicios.
CUTS: Clave Única de Trámites y Servicios, que consiste en la clave digital que emite la Unidad, por la cual se reconoce la identidad electrónica de los sujetos inscritos en el Registro Único de Personas Acreditadas en el Estado de México.
Documento electrónico:
Todo soporte escrito con caracteres alfanuméricos, archivo de imagen, video, audio o cualquier otro formato tecnológicamente disponible, que contenga información en lenguaje natural o convencional, intercambiado por medios electrónicos, con el que sea posible dar constancia de un hecho.
Firma electrónica: Firma electrónica avanzada, que consiste en el
conjunto de datos electrónicos asociados a una CUTS que, consignados en un mensaje de datos o documento electrónico, tiene como propósito identificar unívocamente al emisor del mismo como autor legítimo de éste, así como la fecha y hora de su emisión.
RETYS: Registro Estatal de Trámites y Servicios, está
conformado por el catálogo de trámites y/o servicios.
Servicio Web El servicio web es un servicio seguro que requiere
que el consumidor se encuentre autenticado en una lista de control de acceso del servidor de la DGSEI.
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 8 de 32
2. Vista General
2.1. Suposiciones y Restricciones
El proceso del trámite o servicio deberá estar automatizado de forma electrónica, ya sea en su totalidad o de forma parcial.
El trámite o servicio debe ejecutarse en un ambiente web o contar con una interface web con la cual comunicarse.
El trámite o servicio debe tener una URL desde la cual se le pueda llamar para ejecutarlo.
Se debe contar con la autorización de la DGSEI para poder consumir los servicios del SEITS. Se requiere contar con un usuario y contraseña que se proporcionará en la DGSEI. (contacto: Anastacio Damian, [email protected], tel. oficina 722.276.9600 ext. 60127)
Se debe contar con usuario y contraseña para desencriptar la cadena de envío del SEITS. Dicha información viene en un archivo que se proporciona, por parte de la DGSEI, al momento de la implementación. (contacto: Anastacio Damian, [email protected], tel. oficina 722.276.9600 ext: 60127)
El trámite o servicio deberá estar registrado en el sistema RETYS con toda su información completa, teniendo principal atención en los datos descritos en la sección “2.3.1 Catálogo de Trámites y Servicios”. Los valores registrados en el RETYS serán usados por los componentes del SEITS para interactuar con el trámite o servicio.
Todo trámite o servicio será ejecutado desde el sistema SEITS basado en la(s) URL(s) definida(s) en el RETYS.
Al ejecutarlo, el sistema SEITS le asignará un folio para identificar cada solicitud (independientemente del folio que internamente maneje cada trámite). Todo el seguimiento al trámite o servicio será a través del folio del SEITS.
Se le asignará el estatus interno de “Solicitado”.
Conforme avance la atención del Trámite o Servicio, este deberá notificar el estatus al SEITS, hasta su conclusión. Esta información será mostrada al usuario cuando consulte el avance de su solicitud en el SEITS.
La Dependencia podrá enviar información al usuario, solicitar documentos o notificar de alguna situación mediante correo electrónico.
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 9 de 32
La Dependencia entregará el resultado final del Trámite o Servicio de forma presencial o a través de correo electrónico, dependiendo de la naturaleza del trámite o servicio.
2.2. Diagrama general de componentes
2.3. Componentes del SEITS El SEITS está conformado por los siguientes componentes:
Catálogo de Trámites y Servicios: Se encuentra implementado en el RETYS, en este componente es donde se registran los siguientes datos, necesarios para la integración del trámite o servicio con el SEITS:
Identificador del trámite. Es indispensable para la comunicación entre el SEITS y el RETYS.
Nombre del trámite. Es el nombre oficial con el cual se dará a conocer el trámite o servicio al ciudadano.
Responsable de prestación del trámite o servicio. Oficina del Gobierno del Estado de México encargada de resolver todas las cuestiones relacionadas con el trámite.
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 10 de 32
Calendario laboral aplicable. Establece los días no laborables para la atención del trámite. Este campo es utilizado para calcular la fecha de caducidad de la solicitud.
Duración del trámite o servicio. Indica el tiempo que tarda el ciudadano de principio a fin en realizar el trámite o servicio ante la dependencia. Este campo es utilizado para calcular la fecha de caducidad de la solicitud.
Canal de Atención. Indica la forma en la que se realiza el trámite, es decir:
o Presencial o Telefónica o En Línea
Tipo de Trámite en Línea. En aquellos trámites que son en línea, indica la subclasificación:
o De principio a fin o Pre-gestión o Chat
Así mismo, por cada uno de los Tipos de Trámite en Línea se determina el siguiente campo:
o Dirección web: Dirección electrónica (URL) de conexión directa al trámite.
Adicionalmente, cuando el Tipo de Trámite en Línea es "De principio a fin" o "Pre-gestión" se definen los siguientes campos: o Ventanilla electrónica única. Indica si el trámite está
implementado dentro del SEITS. o Nivel de autenticidad. En caso de que el trámite o
servicio esté implementado dentro del SEITS, indica la manera en la que inicia el trámite o servicio en línea, puede ser:
Anónimo: No se requiere conocerla identidad del
solicitante. Nivel de seguridad bajo. CUTS inicial: El solicitante ya cuenta con una
clave de usuario CUTS obtenida vía internet. Sin embargo, no se ha presentado físicamente a alguna dependencia gubernamental para validar su identidad. Nivel de seguridad bajo.
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 11 de 32
CUTS validada: El solicitante ya cuenta con una clave de usuario CUTS. Asimismo, se ha presentado físicamente a alguna dependencia gubernamental para validar su identidad. Nivel de seguridad medio.
Firma electrónica: El solicitante cuenta con una clave de usuario CUTS validada, así como una firma electrónica que asegura completamente su identidad. Nivel de seguridad alto.
Anónimo o CUTS Inicial: Cuando la solicitud puede realizarse con cualquiera de las dos modalidades mencionadas. La Ventanilla mostrará las 2 opciones para iniciar la solicitud, sin embargo, sólo se podrá elegir una opción, para la realización del trámite. Nivel de seguridad bajo.
Anónimo o CUTS Validada: Cuando la solicitud puede realizarse con cualquiera de las dos modalidades mencionadas. La Ventanilla mostrará las 2 opciones para iniciar la solicitud, sin embargo, sólo se podrá elegir una opción, para la realización del trámite. Nivel de seguridad bajo/medio, según corresponda.
o ¿Requiere notificación electrónica? En caso de que el
trámite o servicio esté implementado dentro del SEITS, indica si se requiere dar a conocer un mensaje o documento electrónico, que cuente con firma y/o sello electrónico, derivado de actos, procedimientos, trámites y/o resoluciones realizados por el ciudadano, que pueden resultar en sanciones jurídicas y/o administrativas.
Si bien al SEITS está alojado en la infraestructura de la DGSEI cada uno de los trámites y servicios electrónicos continuará alojado en la infraestructura donde radica actualmente, pero se ejecutará desde el SEITS. Por lo anterior, para integrar un trámite o servicio al SEITS, el área responsable del trámite o servicio, debe realizar lo siguiente:
1. Pantalla de acceso a la solicitud del trámite o servicio: Es necesario ajustar la pantalla de solicitud del trámite o servicio para que no pida autenticarse con usuario y password al solicitante (en caso de que así sea). Dicha pantalla de solicitud
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 12 de 32
deberá leer un parámetro web y desencriptarlo (como se muestra en la sección de componentes de comunicación), mostrando la información del solicitante que se recibe en dicho parámetro como: nombre, dirección y correo electrónico.
2. Generar un cliente del servicio web: El servicio es necesario para la actualización de estatus y debe invocarse en cada paso donde el trámite considere necesario avisarle al solicitante el avance en la atención de su trámite.
3. Modificar la pantalla de solicitud y de seguimiento: Para homologar la vista al estándar del SEITS, es necesario modificar la vista actual de los trámites o servicios con el fin de mostrar al ciudadano una ventanilla electrónica única. Además, se deberán homologar los reportes que se emitan para el ciudadano
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 13 de 32
3. Definición técnica de los componentes de comunicación
3.1 Componente A: Comunicación SEITS a trámite
El llamado al trámite o servicio se hace por medio de http enviando el folio y toda la información de la persona que está solicitando el trámite o servicio en un solo parámetro llamado “encodeParameters” que viaja encriptado y se envía por medio de post. Dicho parámetro está codificado en UTF-8, convertido a una cadena de bits en base 64 y encriptado utilizando el algoritmo AES a 128bits por medio de una llave de seguridad que será proporcionada a cada trámite o servicio. Por lo cual, el trámite o servicio deberá de bloquear todas las llamadas que se hagan a su URL que no contengan dicho parámetro y aquellas llamadas que si contengan el parámetro pero que este no se puede desencriptar conforme al estándar. Para poder leer el parámetro el trámite o servicio que lo recibe debe realizar el siguiente proceso (descrito para lenguaje JAVA):
1. Transformar o decodificar el contenido (tipo String) de dicho parámetro, de String Base64 a arreglo de bytes (byte[]).
2. Tomar el arreglo de bytes resultante y descifrarlo usando el algoritmo /AES/ y la llave proporcionada. Esto resulta en un nuevo byte[].
3. Transformar el nuevo arreglo byte[] a String /UTF-8/
Una vez realizado el paso tres, se genera una cadena de caracteres compuesta por elementos de tipo “campo=valor" concatenados con el carácter “&”. Los elementos que componen la cadena son los siguientes:
CAMPO Tipo Tamaño
folio=FE/328-0001/2013 alfanumérico 20
×tamp=dd/mm/yyhh:MM:ss Timestamp -
&cuts=MITA830112HDFRDT02 alfanumérico 20
&nombre=adrian Carácter 50
&apellidoPaterno=miramar Carácter 50
&apellidoMaterno=guadarrama Carácter 50
&celular=7221902322 Numérico 12
&claveServidorPublico=976827143 Numérico 9
&[email protected] alfanumérico 50
&firmaElectronica=true Booleano -
&nivelSeguridad=1 Numérico 1
&tipoTramite=1 Numérico 1
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 14 de 32
Nota: Cabe destacar que para aquellos trámites o servicios que no requieren de CUTS, el SEITS únicamente encriptará la cadena con los primeros 2 campos(folio y timestamp) y el campo de tipoTramite, el resto de los campos no se incluyen en la cadena. El folio que genera el SEITS se compone de la siguiente manera: el prefijo FE (Folio Electrónico) + diagonal + identificador del trámite en el RETYS + guión corto + consecutivo para el trámite + diagonal + año actual en 4 dígitos, ejemplo: FE/756-12/2014. El campo nivelSeguridad, únicamente puede tener el valor 1 (cuando es CUTS Inicial) o 2 (cuando es CUTS validada). El campo tipoTramite indica la manera en la que el solicitante invocó al trámite o servicio en línea, puede ser 1=De principio a fin, 2=Pre-gestion o 3=Chat.
3.2 Componente B: Servicio Web para actualización de estatus El servicio Web es de tipo jax-ws con un tipo de autenticación HTTPBasic que requiere de usuario/contraseña, los cuales serán enviados en la cabecera del mensaje. Dicho usuario será proporcionado para cada trámite cuando se publique en ambiente productivo. En ambiente de desarrollo el usuario es: "cnapUser" y la contraseña es: "qwerty". Los pasos para autenticar son:
Desde Java:Crear un objeto de tipo BindingProvider, donde serán especificados el usuario, contraseña y la url del ServicioWeb.1
Desde PHP: Crear el objeto JaxWsSoapClient que recibe dos parámetros, el primero es la url del WSDL y el segundo parámetro es un arreglo que debe contener los parámetros de location (endpoint), el uri (espacio de trabajo), login (usuario), password (contraseña).2
Una vez autenticado se debe consumir el Servicio Web, para lo cual se deberán enviar los siguientes parámetros: El servicio recibe como parámetros el Folio, Id del Trámite, Id del CUTS, Tipo Solicitud, estatus, subestatus, descripción del subestatus, URL de documentos, URL de seguimiento y tipo de seguimiento. Los cuales se describen a continuación:
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 15 de 32
Folio: Es un dato alfanumérico que es asignado por el SEITS al momento de llamar al trámite, dicho folio se encuentra dentro la cadena encriptada enviada desde el SEITS al trámite en el componente A de comunicación.
Id Trámite: Es el identificador asignado al trámite o servicio al momento de ser registrado en el RETYS. (Este identificador será proporcionado al momento de iniciar la conexión con SEITS)
IdCuts: Es el identificador de la persona, el cual se encuentra dentro de la cadena encriptada enviada desde el SEITS al trámite en el componente A de comunicación.
Tipo Solicitud: Este dato es asignado por el dueño del trámite de acuerdo al nivel de seguridad que tiene el mismo
1.- Anónimo: No se requiere conocer la identidad del solicitante. Nivel de seguridad bajo. 2.- CUTS inicial: El solicitante ya cuenta con una clave de usuario CUTS obtenida vía internet. Sin embargo, no se ha presentado físicamente a alguna dependencia gubernamental para validar su identidad. Nivel de seguridad bajo. 3.- CUTS validada: El solicitante ya cuenta con una clave de usuario CUTS. Asimismo, se ha presentado físicamente a alguna dependencia gubernamental para validar su identidad. Nivel de seguridad medio. 4.- Firma electrónica: El solicitante cuenta con una clave de usuario CUTS validada, así como una firma electrónica que asegura completamente su identidad. Nivel de seguridad alto.
Estatus: Es el que va a indicarle al solicitante el avance general del trámite o servicio. Solamente puede ser alguno de los siguientes valores: 1- Pendiente, 2-En proceso GEM, 3-Cancelado Solicitante, 4-Rechazado GEM, 5-Terminado GEM, 6-En proceso Solicitante.
Subestatus: Es el que indica a detalle el avance del trámite o servicio y este lo determinará cada trámite según corresponda. Es un valor numérico no mayor de 5 posiciones.
Descripción del subestatus: Es el que indica verbalmente a detalle el avance del trámite (ej. solicitud pendiente, pago recibido, en autorización) y este lo determinará cada trámite o servicio según corresponda. Es un dato alfanumérico de máximo 90 posiciones.
URL de Documentos: el cual debe ser la URL que apunte (si aplica) a una pantalla del trámite o servicio donde se muestren los documentos generados por el trámite o servicio, con el objetivo de ya no tener que estar buscando por varios lugares del trámite o servicio los documentos emitidos por el mismo. Es un campo
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 16 de 32
alfanumérico de máximo 256 posiciones. En caso de no contar con ella, favor de enviar el valor null (valor nulo).
URL de seguimiento, debe ser la URL con la cual el SEITS puede invocar al trámite en el apartado o sección correspondiente, de tal forma que al usuario del trámite o servicio lo lleve directamente al paso donde revisa o complementa su información (sin necesidad de solicitar datos adicionales ej. usuario y password). Es un campo alfanumérico de máximo 256 posiciones.
Tipo de Seguimiento, se asigna de acuerdo al estatus del trámite o servicio, específicamente En Proceso se tienen dos tipos.
o Tipo 1, Significa que se encuentra en un proceso del GEM
o Tipo 2, Significa que se encuentra en un proceso del Solicitante
Una vez ejecutado, el servicio web responde con un código 00-Correcto si todo está correcto o con un código mayor a 00 en caso de error. Ejemplo 01-Folio Inválido. La WSDL para consumir el servicio web se encuentra publicada en la siguiente ruta: http://qasistemas2.edomex.gob.mx/seits/AuditoriaSEITS
NOTA: En el caso de que al servicio web de SEITS reciba dos o más veces la misma solicitud, el servicio no retorna ningún error, más bien almacena todas las solicitudes en un historial.
3.3 Componente C: URL para seguimiento o retroalimentación
El llamado a la URL de seguimiento del trámite o servicio se hace por
medio de http, mostrándola en una nueva ventana, enviando el folio y
toda la información de la persona que está solicitando el trámite o
servicio en un solo parámetro llamado “encodeParam” que viaja
encriptado y se envía por medio de post. Dicho parámetro está
codificado en UTF-8, convertido a una cadena de bits en base 64 y
encriptado utilizando el algoritmo AES a 128bits por medio de una llave
de seguridad que será proporcionada a cada trámite. Contiene la misma
información descrita en el componente A de este documento y se envía
para asegurarle al trámite o servicio que el SEITS es quién realiza el
llamado. Por lo cual, el trámite o servicio deberá de bloquear todas las
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 17 de 32
llamadas que se hagan a su URL que no contengan dicho parámetro y
aquellas llamadas que si contengan el parámetro pero que éste no
pueda desencriptar conforme al estándar.
4. Ejemplos
4.1 Ejemplo de la cadena encriptada, para desencriptarla y ver si
efectivamente está funcionando bien el código del trámite.
La cadena (encodeParameters) se mandara de la siguiente manera:
eDvLN3Pt+fRyh/5Ex7c8DSYIldysVt/2Rtt5IuSbxWkrxKMHpZbUEaiXhoj+
YQJYE5t6NjzItwp4Tblm9LyMd5kW8OPn7UQkMFWtXAKCrHR8upy10C9
goBs9X0fhBiDFMb7ZciO82LN9REMl1GsoFBAlXUHr1uMNO3d6vnNKEpBg
MWmEPi2/w1nTx6faob+IxJ8gmv3Lp9lSN3U3icuIUBW6x9gxaE0tnwKi3S
WNqPsI5v0Xvq+Gt/uEUAADj8Wfdd9wVulyOp2wFCCeT5LxJZO3spiw05
r1VDJ8akDHbXcU0vsb+3IDJZlsf0ydjczZGu9x/IgPgEwT93/PACwFgJ/zB
aH50KmsuHxgNw9w3q4=
4.2 Ejemplo del código fuente en JAVA para desencriptar los
parámetros.
Al recibirla cadena en el trámite, se lee el parámetro encodeParameters
y se desencripta, a continuación se muestra un ejemplo de cómo se está
desencriptando en java:
SecretKey key = new
SecretKeySpec(copiarFicheroAMemoria("rutasDeKey"), "AES");
Cipher pbeCipher = Cipher.getInstance("AES");
// Initialize PBE Cipher with key and parameters
pbeCipher.init(Cipher.DECRYPT_MODE, key);
byte[] cleartext =
pbeCipher.doFinal(Base64.decodeBase64(encodeParameters));
String encodeText = new String(cleartext, "UTF-8");
SimpleDateFormatsdf = new
SimpleDateFormat("dd/MM/yyyyHH:mm:ss");
String[] parameters = encodeText.split("&");
String[] varValue;
for (String parameter : parameters) {
varValue = parameter.split("=");
if (varValue[0].equals("folio")) {
folio = varValue[1];
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 18 de 32
} else if (varValue[0].equals("timestamp")) {
timestamp = sdf.parse(varValue[1]);
} else if (varValue[0].equals("cuts")) {
cuts = varValue[1];
}else if (varValue[0].equals("idTramite")) {
idTramite = Integer.parseInt(varValue[1]);
}else if (varValue[0].equals("nombre")) {
nombre = varValue[1];
}else if (varValue[0].equals("apellidoPaterno")) {
apellidoPaterno = varValue[1];
}else if (varValue[0].equals("apellidoMaterno")) {
apellidoMaterno = varValue[1];
} }
importjavax.crypto.SecretKey;
importjavax.crypto.spec.SecretKeySpec;
private static byte[] copiarFicheroAMemoria(String ruta) throws
IOException {
byte[] contenidoDelFichero = null;
File file = new File(ruta);
FileInputStreamfis;
BufferedInputStreambis = null;
long l = file.length();
byte[] buffer = new byte[(int) l];
intleido;
ByteArrayOutputStreambos = new ByteArrayOutputStream();
try { fis = new FileInputStream(file);
bis = new BufferedInputStream(fis);
while ((leido = bis.read(buffer)) >= 0) {
bos.write(buffer, 0, leido); }
contenidoDelFichero = bos.toByteArray();
bos.reset();
bos.close();
} catch (IOException e1) {
throw e1;
} finally {
if (bis != null) {
try {
bis.close();
} catch (IOException e) {
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 19 de 32
throw e; } } }
returncontenidoDelFichero; }
4.3 Ejemplo de la URL para ingresar desde el SEITS y probar los
cambios realizados.
La dirección electrónica (URL) para pruebas de los trámites es:
http://qasistemas2.edomex.gob.mx/seits/views/pruebaBootstrap.jsp
El usuario y password de acceso será otorgado durante las pruebas que
se realicen para la conexión con el SEITS.
4.4 Ejemplo del código fuente en PHP para desencriptar los
parámetros.
De manera similar al ejemplo con código java, al recibir la cadena en el
trámite, se lee el parámetro encodeParameters y se desencripta, a
continuación se muestra un ejemplo de cómo se está desencriptando en
java:
<?php
include("./AES.class.php");
$llave =file_get_contents("./key.dat");
$aes = new AES($llave);
if (!isset($_POST["encodeParameters"]) || empty($_POST["encodeParameters"] )) {
$error = "No se recibio el parametro. Su consulta no fue autorizada";
echo $error;
}
else {
$data = $_POST["encodeParameters"];
//1. Transformar o decodificar el contenido (tipo String) de dicho parámetro, de
String Base64 a arreglo de bytes (byte[]).
$a = base64_decode($data);
//2.Tomar el arreglo de bytes resultante y descifrarlo usando el algoritmo /AES/ y
la llave proporcionada. Esto resulta en un nuevo byte[].
$b = $aes->decrypt($a);
//3. Transformar el nuevo arreglo byte[] a String /UTF-8/
$c = utf8_decode($b);
$arreglo = explode('&',utf8_decode($c));
$Arreglo_Folio = explode('=',$arreglo[0]);
$FFolio = $Arreglo_Folio[1];
$Arreglo_TE = explode('=',$arreglo[1]);
$dTimeStamp = $Arreglo_TE[1];
$Arreglo_FechaDia = explode(' ',$Arreglo_TE[1]);
$Hora = $Arreglo_FechaDia[1];
$Arreglo_SoloFecha = explode('/',$Arreglo_FechaDia[0]);
//Formato actual 19/06/2014 09:23:46 'dd/mm/rrrr'
$Anio = $Arreglo_SoloFecha[2];
$Mes = $Arreglo_SoloFecha[1];
$Dia = $Arreglo_SoloFecha[0];
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 20 de 32
$FTimeStamp = $Anio ."/". $Mes ."/". $Dia ." ". $Hora;
$Arreglo_ID = explode('=',$arreglo[2]);
$FIDTramite = $Arreglo_ID[1];
//4.Guardar en la Base de datos los datos de Folio, TimeStamp e ID del Trámite
include "conecta.php";
$result = mysql_query("SELECT Folio FROM mitabla WHERE Folio = '$FFolio'");
$numfilas = mysql_num_rows($result);
if($numfilas != 0) {
$fila = mysql_fetch_array($result, MYSQL_ASSOC);
$FFolio = $fila["FFolio"];
echo "ya existe el registro: " .$FFolio;
}
else {
$result = mysql_query("INSERT INTO mitabla (Folio, TimeStam, IDTramit) VALUES
('$FFolio', '$FTimeStamp', '$FIDTramite')");
if ($result) {
echo "se insertó el registro: " .$FFolio;
}
else {
echo "<p><br>error al insertar el registro</p>";
}
}
//5. Redireccionar al Registro Estatal de Inspectores, para permitirle al ciudadano
realizar la consulta …
}
?>
Contenido del archivo "AES.class.php"
<?php
/*
* Author: Cody Phillips
* Company: Phillips Data
* Website: www.phpaes.com, www.phillipsdata.com
* File: AES.class.php
* October 1, 2007
*
* This software is sold as-is without any warranties, expressed or implied,
* including but not limited to performance and/or merchantability. No
* warranty of fitness for a particular purpose is offered. This script can
* be used on as many servers as needed, as long as the servers are owned
* by the purchaser. (Contact us if you want to distribute it as part of
* another project) The purchaser cannot modify, rewrite, edit, or change any
* of this code and then resell it, which would be copyright infringement.
* This code can be modified for personal use only.
*
* Comments, Questions? Contact the author at cody [at] wshost [dot] net
*/
class AES {
// The number of 32-bit words comprising the plaintext and columns comrising
the state matrix of an AES cipher.
private static $Nb = 4;
// The number of 32-bit words comprising the cipher key in this AES cipher.
private $Nk;
// The number of rounds in this AES cipher.
private $Nr;
// The S-Box substitution table.
private static $sBox = array(
0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5,
0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 21 de 32
0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc,
0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a,
0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,
0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b,
0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85,
0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,
0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17,
0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88,
0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c,
0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9,
0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6,
0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e,
0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94,
0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68,
0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
);
// The inverse S-Box substitution table.
private static $invSBox = array(
0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38,
0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87,
0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d,
0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2,
0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16,
0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda,
0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a,
0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02,
0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea,
0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85,
0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89,
0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20,
0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31,
0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d,
0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 22 de 32
0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0,
0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26,
0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d
);
// Log table based on 0xe5
private static $ltable = array(
0x00, 0xff, 0xc8, 0x08, 0x91, 0x10, 0xd0, 0x36,
0x5a, 0x3e, 0xd8, 0x43, 0x99, 0x77, 0xfe, 0x18,
0x23, 0x20, 0x07, 0x70, 0xa1, 0x6c, 0x0c, 0x7f,
0x62, 0x8b, 0x40, 0x46, 0xc7, 0x4b, 0xe0, 0x0e,
0xeb, 0x16, 0xe8, 0xad, 0xcf, 0xcd, 0x39, 0x53,
0x6a, 0x27, 0x35, 0x93, 0xd4, 0x4e, 0x48, 0xc3,
0x2b, 0x79, 0x54, 0x28, 0x09, 0x78, 0x0f, 0x21,
0x90, 0x87, 0x14, 0x2a, 0xa9, 0x9c, 0xd6, 0x74,
0xb4, 0x7c, 0xde, 0xed, 0xb1, 0x86, 0x76, 0xa4,
0x98, 0xe2, 0x96, 0x8f, 0x02, 0x32, 0x1c, 0xc1,
0x33, 0xee, 0xef, 0x81, 0xfd, 0x30, 0x5c, 0x13,
0x9d, 0x29, 0x17, 0xc4, 0x11, 0x44, 0x8c, 0x80,
0xf3, 0x73, 0x42, 0x1e, 0x1d, 0xb5, 0xf0, 0x12,
0xd1, 0x5b, 0x41, 0xa2, 0xd7, 0x2c, 0xe9, 0xd5,
0x59, 0xcb, 0x50, 0xa8, 0xdc, 0xfc, 0xf2, 0x56,
0x72, 0xa6, 0x65, 0x2f, 0x9f, 0x9b, 0x3d, 0xba,
0x7d, 0xc2, 0x45, 0x82, 0xa7, 0x57, 0xb6, 0xa3,
0x7a, 0x75, 0x4f, 0xae, 0x3f, 0x37, 0x6d, 0x47,
0x61, 0xbe, 0xab, 0xd3, 0x5f, 0xb0, 0x58, 0xaf,
0xca, 0x5e, 0xfa, 0x85, 0xe4, 0x4d, 0x8a, 0x05,
0xfb, 0x60, 0xb7, 0x7b, 0xb8, 0x26, 0x4a, 0x67,
0xc6, 0x1a, 0xf8, 0x69, 0x25, 0xb3, 0xdb, 0xbd,
0x66, 0xdd, 0xf1, 0xd2, 0xdf, 0x03, 0x8d, 0x34,
0xd9, 0x92, 0x0d, 0x63, 0x55, 0xaa, 0x49, 0xec,
0xbc, 0x95, 0x3c, 0x84, 0x0b, 0xf5, 0xe6, 0xe7,
0xe5, 0xac, 0x7e, 0x6e, 0xb9, 0xf9, 0xda, 0x8e,
0x9a, 0xc9, 0x24, 0xe1, 0x0a, 0x15, 0x6b, 0x3a,
0xa0, 0x51, 0xf4, 0xea, 0xb2, 0x97, 0x9e, 0x5d,
0x22, 0x88, 0x94, 0xce, 0x19, 0x01, 0x71, 0x4c,
0xa5, 0xe3, 0xc5, 0x31, 0xbb, 0xcc, 0x1f, 0x2d,
0x3b, 0x52, 0x6f, 0xf6, 0x2e, 0x89, 0xf7, 0xc0,
0x68, 0x1b, 0x64, 0x04, 0x06, 0xbf, 0x83, 0x38
);
// Inverse log table
private static $atable = array(
0x01, 0xe5, 0x4c, 0xb5, 0xfb, 0x9f, 0xfc, 0x12,
0x03, 0x34, 0xd4, 0xc4, 0x16, 0xba, 0x1f, 0x36,
0x05, 0x5c, 0x67, 0x57, 0x3a, 0xd5, 0x21, 0x5a,
0x0f, 0xe4, 0xa9, 0xf9, 0x4e, 0x64, 0x63, 0xee,
0x11, 0x37, 0xe0, 0x10, 0xd2, 0xac, 0xa5, 0x29,
0x33, 0x59, 0x3b, 0x30, 0x6d, 0xef, 0xf4, 0x7b,
0x55, 0xeb, 0x4d, 0x50, 0xb7, 0x2a, 0x07, 0x8d,
0xff, 0x26, 0xd7, 0xf0, 0xc2, 0x7e, 0x09, 0x8c,
0x1a, 0x6a, 0x62, 0x0b, 0x5d, 0x82, 0x1b, 0x8f,
0x2e, 0xbe, 0xa6, 0x1d, 0xe7, 0x9d, 0x2d, 0x8a,
0x72, 0xd9, 0xf1, 0x27, 0x32, 0xbc, 0x77, 0x85,
0x96, 0x70, 0x08, 0x69, 0x56, 0xdf, 0x99, 0x94,
0xa1, 0x90, 0x18, 0xbb, 0xfa, 0x7a, 0xb0, 0xa7,
0xf8, 0xab, 0x28, 0xd6, 0x15, 0x8e, 0xcb, 0xf2,
0x13, 0xe6, 0x78, 0x61, 0x3f, 0x89, 0x46, 0x0d,
0x35, 0x31, 0x88, 0xa3, 0x41, 0x80, 0xca, 0x17,
0x5f, 0x53, 0x83, 0xfe, 0xc3, 0x9b, 0x45, 0x39,
0xe1, 0xf5, 0x9e, 0x19, 0x5e, 0xb6, 0xcf, 0x4b,
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 23 de 32
0x38, 0x04, 0xb9, 0x2b, 0xe2, 0xc1, 0x4a, 0xdd,
0x48, 0x0c, 0xd0, 0x7d, 0x3d, 0x58, 0xde, 0x7c,
0xd8, 0x14, 0x6b, 0x87, 0x47, 0xe8, 0x79, 0x84,
0x73, 0x3c, 0xbd, 0x92, 0xc9, 0x23, 0x8b, 0x97,
0x95, 0x44, 0xdc, 0xad, 0x40, 0x65, 0x86, 0xa2,
0xa4, 0xcc, 0x7f, 0xec, 0xc0, 0xaf, 0x91, 0xfd,
0xf7, 0x4f, 0x81, 0x2f, 0x5b, 0xea, 0xa8, 0x1c,
0x02, 0xd1, 0x98, 0x71, 0xed, 0x25, 0xe3, 0x24,
0x06, 0x68, 0xb3, 0x93, 0x2c, 0x6f, 0x3e, 0x6c,
0x0a, 0xb8, 0xce, 0xae, 0x74, 0xb1, 0x42, 0xb4,
0x1e, 0xd3, 0x49, 0xe9, 0x9c, 0xc8, 0xc6, 0xc7,
0x22, 0x6e, 0xdb, 0x20, 0xbf, 0x43, 0x51, 0x52,
0x66, 0xb2, 0x76, 0x60, 0xda, 0xc5, 0xf3, 0xf6,
0xaa, 0xcd, 0x9a, 0xa0, 0x75, 0x54, 0x0e, 0x01
);
// The key schedule in this AES cipher.
private $w;
// The state matrix in this AES cipher with Nb columns and 4 rows
private $s;
// Determines the lenght of key z
private $keyLength;
/** constructs an AES cipher using a specific key.
*/
public function __construct($z) {
$this->Nk = strlen($z)/4;
$this->Nr = $this->Nk + self::$Nb + 2;
if ($this->Nk != 4 && $this->Nk != 6 && $this->Nk != 8)
die("Key is " . ($this->Nk*32) ." bits long. *not* 128, 192, or 256.");
$this->Nr = $this->Nk+self::$Nb+2;
$this->w = array(); // Nb*(Nr+1) 32-bit words
$this->s = array(array()); // 2-D array of Nbcolums and 4 rows
$this->KeyExpansion($z); // places expanded key in w
}
/** Encrypts an aribtrary length String.
* @params plaintext string
* @returns ciphertext string
* Whenever possible you should stream your plaintext through the
* encryptBlock() function directly, as the amount of time required
* to encrypt is linear to the size of the ciphertext.
**/
public function encrypt($x) {
$t = ""; // 16-byte block
$y = ""; // returned cipher text;
// put a 16-byte block into t
$xsize = strlen($x);
for ($i=0; $i<$xsize; $i+=16) {
for ($j=0; $j<16; $j++) {
if (($i+$j)<$xsize) {
$t[$j] = $x[$i+$j];
}
else
$t[$j] = chr(0);
}
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 24 de 32
$y .= $this->encryptBlock($t);
}
return $y;
}
/** Decrypts an aribtrary length String.
* @paramsciphertext string
* @returns plaintext string
* Whenever possible you should stream your ciphertext through the
* decryptBlock() function directly, as the amount of time required
* to decrypt is linear to the size of the ciphertext.
**/
public function decrypt($y) {
$t = ""; // 16-byte block
$x = ""; // returned plain text;
// put a 16-byte block into t
$ysize = strlen($y);
for ($i=0; $i<$ysize; $i+=16) {
for ($j=0; $j<16; $j++) {
if (($i+$j)<$ysize)
$t[$j] = $y[$i+$j];
else
$t[$j] = chr(0);
}
$x .= $this->decryptBlock($t);
}
return $x;
}
/** Encrypts the 16-byte plain text.
* @params 16-byte plaintext string
* @returns 16-byte ciphertext string
**/
public function encryptBlock($x) {
$y = ""; // 16-byte string
// place input x into the initial state matrix in column order
for ($i=0; $i<4*self::$Nb; $i++) {
// we want integerger division for the second index
$this->s[$i%4][($i-$i%self::$Nb)/self::$Nb] = ord($x[$i]);
}
// add round key
$this->addRoundKey(0);
for ($i=1; $i<$this->Nr; $i++) {
// substitute bytes
$this->subBytes();
// shift rows
$this->shiftRows();
// mix columns
$this->mixColumns();
// add round key
$this->addRoundKey($i);
}
// substitute bytes
$this->subBytes();
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 25 de 32
// shift rows
$this->shiftRows();
// add round key
$this->addRoundKey($i);
// place state matrix s into y in column order
for ($i=0; $i<4*self::$Nb; $i++)
$y .=chr($this->s[$i%4][($i-$i%self::$Nb)/self::$Nb]);
return $y;
}
/** Decrypts the 16-byte cipher text.
* @params 16-byte ciphertext string
* @returns 16-byte plaintext string
**/
public function decryptBlock($y) {
$x = ""; // 16-byte string
// place input y into the initial state matrix in column order
for ($i=0; $i<4*self::$Nb; $i++)
$this->s[$i%4][($i-$i%self::$Nb)/self::$Nb] = ord($y[$i]);
// add round key
$this->addRoundKey($this->Nr);
for ($i=$this->Nr-1; $i>0; $i--) {
// inverse shift rows
$this->invShiftRows();
// inverse sub bytes
$this->invSubBytes();
// add round key
$this->addRoundKey($i);
// inverse mix columns
$this->invMixColumns();
}
// inverse shift rows
$this->invShiftRows();
// inverse sub bytes
$this->invSubBytes();
// add round key
$this->addRoundKey($i);
// place state matrix s into x in column order
for ($i=0; $i<4*self::$Nb; $i++) {
// Used to remove filled null characters.
$x .= ($this->s[$i%4][($i-$i%self::$Nb)/self::$Nb] == chr(0)
? "" :chr($this->s[$i%4][($i-$i%self::$Nb)/self::$Nb]));
}
return $x;
}
public function __destruct() {
unset($this->w);
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 26 de 32
unset($this->s);
}
/** makes a big key out of a small one
* @returns void
**/
private function KeyExpansion($z) {
// Rcon is the round constant
static $Rcon = array(
0x00000000,
0x01000000,
0x02000000,
0x04000000,
0x08000000,
0x10000000,
0x20000000,
0x40000000,
0x80000000,
0x1b000000,
0x36000000,
0x6c000000,
0xd8000000,
0xab000000,
0x4d000000,
0x9a000000,
0x2f000000
);
$temp = 0; // temporary 32-bit word
// the first Nk words of w are the cipher key z
for ($i=0; $i<$this->Nk; $i++) {
$this->w[$i] = 0;
// fill an entire word of expanded key w
// by pushing 4 bytes into the w[i] word
$this->w[$i] = ord($z[4*$i]); // add a byte in
$this->w[$i] <<= 8; // make room for the next byte
$this->w[$i] += ord($z[4*$i+1]);
$this->w[$i] <<= 8;
$this->w[$i] += ord($z[4*$i+2]);
$this->w[$i] <<= 8;
$this->w[$i] += ord($z[4*$i+3]);
}
for (; $i<self::$Nb*($this->Nr+1); $i++) {
$temp = $this->w[$i-1];
if ($i%$this->Nk == 0)
$temp = $this->subWord($this->rotWord($temp)) ^
$Rcon[$i/$this->Nk];
else if ($this->Nk> 6 && $i%$this->Nk == 4)
$temp = $this->subWord($temp);
$this->w[$i] = $this->w[$i-$this->Nk] ^ $temp;
self::make32BitWord($this->w[$i]);
}
}
/** adds the key schedule for a round to a state matrix.
* @returns void
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 27 de 32
**/
private function addRoundKey($round) {
$temp = "";
for ($i=0; $i<4; $i++) {
for ($j=0; $j<self::$Nb; $j++) {
// place the i-th byte of the j-th word from
expanded key w into temp
$temp = $this->w[$round*self::$Nb+$j] >> (3-$i)*8;
// Cast temp from a 32-bit word into an 8-bit byte.
$temp %= 256;
// Can't do unsigned shifts, so we need to make this
temp positive
$temp = ($temp <0 ? (256 + $temp) : $temp);
$this->s[$i][$j] ^= $temp; // xor temp with the byte
at location (i,j) of the state
}
}
}
/** unmixes each column of a state matrix.
* @returns void
**/
private function invMixColumns() {
$s0 = $s1 = $s2 = $s3= '';
// There are Nb columns
for ($i=0; $i<self::$Nb; $i++) {
$s0 = $this->s[0][$i]; $s1 = $this->s[1][$i]; $s2 = $this-
>s[2][$i]; $s3 = $this->s[3][$i];
$this->s[0][$i] = $this->mult(0x0e, $s0) ^ $this->mult(0x0b,
$s1) ^ $this->mult(0x0d, $s2) ^ $this->mult(0x09, $s3);
$this->s[1][$i] = $this->mult(0x09, $s0) ^ $this->mult(0x0e,
$s1) ^ $this->mult(0x0b, $s2) ^ $this->mult(0x0d, $s3);
$this->s[2][$i] = $this->mult(0x0d, $s0) ^ $this->mult(0x09,
$s1) ^ $this->mult(0x0e, $s2) ^ $this->mult(0x0b, $s3);
$this->s[3][$i] = $this->mult(0x0b, $s0) ^ $this->mult(0x0d,
$s1) ^ $this->mult(0x09, $s2) ^ $this->mult(0x0e, $s3);
}
}
/** applies an inverse cyclic shift to the last 3 rows of a state matrix.
* @returns void
**/
private function invShiftRows() {
$temp = "";
for ($i=1; $i<4; $i++) {
for ($j=0; $j<self::$Nb; $j++)
$temp[($i+$j)%self::$Nb] = $this->s[$i][$j];
for ($j=0; $j<self::$Nb; $j++)
$this->s[$i][$j] = $temp[$j];
}
}
/** applies inverse S-Box substitution to each byte of a state matrix.
* @returns void
**/
private function invSubBytes() {
for ($i=0; $i<4; $i++)
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 28 de 32
for ($j=0; $j<self::$Nb; $j++)
$this->s[$i][$j] = self::$invSBox[$this->s[$i][$j]];
}
/** mixes each column of a state matrix.
* @returns void
**/
private function mixColumns() {
$s0 = $s1 = $s2 = $s3= '';
// There are Nb columns
for ($i=0; $i<self::$Nb; $i++) {
$s0 = $this->s[0][$i]; $s1 = $this->s[1][$i]; $s2 = $this-
>s[2][$i]; $s3 = $this->s[3][$i];
$this->s[0][$i] = $this->mult(0x02, $s0) ^ $this->mult(0x03,
$s1) ^ $this->mult(0x01, $s2) ^ $this->mult(0x01, $s3);
$this->s[1][$i] = $this->mult(0x01, $s0) ^ $this->mult(0x02,
$s1) ^ $this->mult(0x03, $s2) ^ $this->mult(0x01, $s3);
$this->s[2][$i] = $this->mult(0x01, $s0) ^ $this->mult(0x01,
$s1) ^ $this->mult(0x02, $s2) ^ $this->mult(0x03, $s3);
$this->s[3][$i] = $this->mult(0x03, $s0) ^ $this->mult(0x01,
$s1) ^ $this->mult(0x01, $s2) ^ $this->mult(0x02, $s3);
}
}
/** applies a cyclic shift to the last 3 rows of a state matrix.
* @returns void
**/
private function shiftRows() {
$temp = "";
for ($i=1; $i<4; $i++) {
for ($j=0; $j<self::$Nb; $j++)
$temp[$j] = $this->s[$i][($j+$i)%self::$Nb];
for ($j=0; $j<self::$Nb; $j++)
$this->s[$i][$j] = $temp[$j];
}
}
/** applies S-Box substitution to each byte of a state matrix.
* @returns void
**/
private function subBytes() {
for ($i=0; $i<4; $i++) {
for ($j=0; $j<self::$Nb; $j++)
$this->s[$i][$j] = self::$sBox[$this->s[$i][$j]];
}
}
/** multiplies two polynomials a(x), b(x) in GF(2^8) modulo the irreducible
polynomial m(x) = x^8+x^4+x^3+x+1
* @returns 8-bit value
**/
private static function mult($a, $b) {
$sum = self::$ltable[$a] + self::$ltable[$b];
$sum %= 255;
// Get the antilog
$sum = self::$atable[$sum];
return ($a == 0 ? 0 : ($b == 0 ? 0 : $sum));
}
/** applies a cyclic permutation to a 4-byte word.
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 29 de 32
* @returns 32-bit int
**/
private static function rotWord($w) {
$temp = $w >> 24; // put the first 8-bits into temp
$w <<= 8; // make room for temp to fill the lower end of the word
self::make32BitWord($w);
// Can't do unsigned shifts, so we need to make this temp positive
$temp = ($temp <0 ? (256 + $temp) : $temp);
$w += $temp;
return $w;
}
/** applies S-box substitution to each byte of a 4-byte word.
* @returns 32-bit int
**/
private static function subWord($w) {
$temp = 0;
// loop through 4 bytes of a word
for ($i=0; $i<4; $i++) {
$temp = $w >> 24; // put the first 8-bits into temp
// Can't do unsigned shifts, so we need to make this temp
positive
$temp = ($temp <0 ? (256 + $temp) : $temp);
$w <<= 8; // make room for the substituted byte in w;
self::make32BitWord($w);
$w += self::$sBox[$temp]; // add the substituted byte back
}
self::make32BitWord($w);
return $w;
}
/** reduces a 64-bit word to a 32-bit word
* @returns void
**/
private static function make32BitWord(&$w) {
// Reduce this 64-bit word to 32-bits on 64-bit machines
$w &= 0x00000000FFFFFFFF;
}
}
?>
4.5 Ejemplo del código fuente en PHP para consumir el servicio web.
<?php
classJaxWsSoapClient extends SoapClient
{
public function __call($method, $arguments){
$response = parent::__call($method, $arguments);
return $response->return;
}
}
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 30 de 32
if (!isset($_POST["ID"]) || empty($_POST["ID"] )) {
$error = "No se recibió el parámetro. La actualización del estatus no fue
autorizada";
echo $error;
}
else {
include "conecta.php";
$FNCIFoVe = $_POST["ID"];
$ResuCons = $_POST["ResuCons"];
if ($ResuCons == "CE"){
$SubEstatus = "Consulta con resultados";
}
else {
$SubEstatus = "Consulta sin resultados";
}
//Codigo para actualizar en la BD de la Contraloria el resultado de la
consulta en el REI
$result = mysql_query("SELECT FFolio, FIDTramit FROM mitabla WHERE FNCIFoVe =
$FNCIFoVe");
$numfilas = mysql_num_rows($result);
if($numfilas != 0) {
$fila = mysql_fetch_array($result, MYSQL_ASSOC);
$FFolio = $fila["FFolio"];
$FIDTramit= $fila["FIDTramit"];
$result = mysql_query("UPDATE mitabla SET FSubEstatu ='$ResuCons' WHERE FNCIFoVe =
$FNCIFoVe");
if ($result)
echo "El resultado de la consulta ha sido actualizado para el Folio: '
$FFolio'<br>";
else
echo "Error al actualizar el resultado de la consulta para el Folio: '$FFolio'<br>";
mysql_close();
//Inicia código para invocar al webservice
ini_set('soap.wsdl_cache_enabled',0);
ini_set('soap.wsdl_cache_ttl',0);
try {
$client = new JaxWsSoapClient
("http://qasistemas2.edomex.gob.mx:80/seits/AuditoriaSEITS?wsdl",
array( "login" => "cnapUser",
"password" => "qwerty"
));
$Respuesta = $client->guardar(array(
'folio' => $FFolio,
'idtramite' => $FIDTramit,
'idCuts' => 'Anonimo',
'idTipoSolicitud' => 1, // Anonimo
'idStatus' => 5,// 5-Terminado GEM
'idSubStatus'=> 0,
'descripcion' => $SubEstatus,
'urlDocumento' => NULL,
'urlSeguimiento' =>
"http://187.191.52.135:8090/seits/REI/ResultadoConsulta.php",
'tipoSeguimiento' => 0));
echo "Respuesta del webservice: '$Respuesta' <br>";
if (substr($Respuesta,0,2) == "00"){
echo "Cerrar ventana<br>";
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 31 de 32
}
else {
echo $Respuesta;
}
}catch(SoapFault $exception) {
print_r("Got issue:<br/>") ;
print_r($exception->getMessage());
}
}
else {
echo "No se encontró el registro: " .$FNCIFoVe;
}
}
?>
5. Referencias
5.1 Documentación en Internet
1. http://www.javadocexamples.com/javax/xml/ws/javax.xml.ws.
BindingProvider.html
2. https://gist.github.com/marifrahman/2183008
5.2 Diagrama de Flujo
Guía para la Integración de Trámites Electrónicos al SEITS
Código
Revisión 0
Fecha 10-04-2013
Página 32 de 32
