INSTITUTO POLITECNICO NACIONAL ESCUELA SUPERIOR DE INGENIERIA MECANICA Y ELECTRICA UNIDAD CULHUACAN SECCIÓN DE ESTUDIOS DE POSTGRADO E INVESTIGACIÓN ESPECIALIZACIÓN EN SEGURIDAD INFORMÁTICA Y TECNOLOGIAS DE LA INFORMACIÓN PRESENTA: CANO JIMÉNEZ ABEL OCULTAMIENTO DE INFORMACIÓN EN DOCUMENTOS ELECTRONICOS DE TIPO POSTSCRIPT PARA OBTENER EL TITULO DE ESPECIALISTA EN SEGURIDAD INFORMÁTICA Y TECNOLOGÍAS DE LA INFORMACIÓN ASESOR: DR. MARIO GONZÁLEZ LEE 1 2 3 CONTENIDO CONTENIDO ................................................................................................................................................ 4 INTRODUCCION ............................................................................................................................................. 9 CAPITULO 1....................................................................................................................................................10 HIPOTESIS .................................................................................................................................................10 OBJETIVO ...................................................................................................................................................11 PLANTEAMIENTO DEL PROBLEMA ...............................................................................................12 DELIMITACIÓN........................................................................................................................................14 ESQUEMA ...................................................................................................................................................15 ESTADO DEL ARTE ................................................................................................................................16 Steganopic 0.1 (Windows)............................................................................................................17 Cloak 7.0 (Windows)........................................................................................................................17 CryptoMX 1.1 (Win Mac Lin) ........................................................................................................17 Dound’s Steganography 1.6 (Windows) ..................................................................................17 Hip 2.0 (Windows) ............................................................................................................................17 UnderMP3Cover 1.1 (Linux).........................................................................................................17 Hide In Picture 2.1 (Windows) ....................................................................................................18 S−Tools (Windows) ..........................................................................................................................18 Wodax 1.2 (Windows) .....................................................................................................................18 Absolute Chaos 3.8 (Windows)....................................................................................................18 Hide In Picture 2.1 (Windows) ....................................................................................................18 MP3Stego (Windows, Linux) ........................................................................................................18 Invisible Secret 4 (Windows) .......................................................................................................18 InvisibleInk (Windows) ..................................................................................................................19 Steganography (Windows)............................................................................................................19 Hermetic Stego (Windows) ...........................................................................................................19 4 BitCrypt (Windows) .........................................................................................................................19 Bon Kyu Bon 1.1.3011 (Windows).............................................................................................19 SteganoG 1.21 (Windows) .............................................................................................................20 PicCrypt 0.3 (Windows)..................................................................................................................20 Xiao Steganography 2.6.1 (Windows) ......................................................................................20 ByteShelter 1 (Windows)...............................................................................................................21 Digital Identity 1.0.16 (Windows)..............................................................................................21 HIP (Hide In Picture) 2.1 (Windows)........................................................................................22 Secure Share 1.0 (Windows).........................................................................................................22 StegHide (Windows, Linux)...........................................................................................................22 AdaStegano (Windows, Linux).....................................................................................................22 CryptArkan (Windows)...................................................................................................................23 Xidie Security Suite (Windows)...................................................................................................23 OutGuess (Unix Linux).....................................................................................................................23 Camera / Shy (Windows)...............................................................................................................23 JPHIDE y JPSEEK (Windows)........................................................................................................23 Hydan (Unix Linux Windows)......................................................................................................24 CAPITULO 2....................................................................................................................................................25 POSTSCRIPT..............................................................................................................................................25 Lenguajes de Descripción de Pagina ..............................................................................................26 Estructura del Lenguaje.......................................................................................................................26 Programación en PostScript ..............................................................................................................27 Números .....................................................................................................................................................28 Strings..........................................................................................................................................................28 Nombres .....................................................................................................................................................29 Arreglos.......................................................................................................................................................29 Procedimientos........................................................................................................................................29 5 Ejecución ....................................................................................................................................................29 Estructuras de control..........................................................................................................................30 SELECCIÓN DEL LENGUAJE DE PROGRAMACIÓN ...................................................................32 SELECCIÓN DE MODULOS A DESARROLLAR .............................................................................32 CAPITULO 3....................................................................................................................................................34 ARCHIVOS DE TEXTO ...........................................................................................................................34 ARCHIVOS POSTCRIPT.........................................................................................................................35 FORMATOS COMPARATIVOS TEXTO Y POSTSCRIPT.............................................................36 CAPITULO 4....................................................................................................................................................37 DESARROLLO DEL GENERADOR .....................................................................................................37 Modo de Funcionamiento ..............................................................................................................38 Técnica Esteganografica .................................................................................................................40 DESARROLLO DEL EXTRACTOR ......................................................................................................44 Uso Ciclo Ocultamiento – Recuperación .......................................................................................46 Parámetros para el Ocultamiento....................................................................................................46 Parámetros y uso de Portadores.................................................................................................48 Parámetros y uso de Extracción..................................................................................................51 CAPITULO 5....................................................................................................................................................55 PRUEBA MOS............................................................................................................................................55 Elaboración...........................................................................................................................................55 RESULTADOS............................................................................................................................................59 APLICACIONES Y USOS ........................................................................................................................61 CAPITULO 6....................................................................................................................................................63 Modificaciones Futuras........................................................................................................................63 POSIBLES MEJORAS...............................................................................................................................63 Ampliar opciones de Formato......................................................................................................64 Criptografía antes de Esteganografía........................................................................................64 6 Disminuir tamaño de archivos finales ......................................................................................64 Incluir archivos multimedia..........................................................................................................65 Incluir archivos binarios o ejecutables.....................................................................................65 Compilación en otros Sistemas Operativos............................................................................66 CAPITULO 7....................................................................................................................................................67 CONCLUSIONES.......................................................................................................................................67 BIBLIOGRAFIA .........................................................................................................................................68 ANEXO 1......................................................................................................................................................70 Código Fuente del Generador.......................................................................................................70 Código Fuente del Extractor .........................................................................................................81 Fig. 1. Bloques de Desarrollo ..............................................................................................................15 Fig. 2. Tabla de Codificaciones ...........................................................................................................27 Fig. 3. Flujo de Esteganografía Propuesto.....................................................................................33 Fig. 4. Flujo de Extracción Propuesto..............................................................................................33 Fig. 5. Aspecto del generador sobre la línea de comando ......................................................37 Fig. 6. Flujo de Ocultación de Información ...................................................................................38 Fig. 7. Archivo de Texto Portador .....................................................................................................39 Fig. 8. Archivo PostScript resultante ...............................................................................................40 Fig. 9. Métricas de un carácter ...........................................................................................................41 Fig. 10. Comparativa de Textos..........................................................................................................42 Fig. 11. Estructura PostScript con información Oculta ...........................................................42 Fig. 12. Estructura PostScript sin información Oculta.............................................................43 Fig. 13. Archivo PostScript Sin Información Oculta ..................................................................43 Fig. 14. Archivo PostScript Con Información Oculta ................................................................43 7 Fig. 15. Comando de Generación de PS con información Oculta.........................................44 Fig. 16. Flujo de Extracción..................................................................................................................45 Fig. 17. Utilización en línea de comando para el programa Extractor..............................46 Fig. 18. Definición de Parámetros de formato en ejecución del programa generador 47 Fig. 19. Estructura de ficheros ejemplo en Sistema de Archivos ........................................48 Fig. 20. Ejemplo de contenido en archivos de Texto ................................................................49 Fig. 21. Nombres de archivos PS generados ................................................................................49 Fig. 22. Comparativa ente texto plano y texto en PostScript ................................................50 Fig. 23. Archivos de prueba para Extracción ...............................................................................51 Fig. 24. Apariencia de una recuperación de Información.......................................................52 Fig. 25. Ejemplo de Ocultación entre el mismo texto ...............................................................53 Fig. 26. Extracción de un archivo oculto en si mismo ..............................................................54 Fig. 27. Formato para evaluación MOS de Impresiones PS ...................................................56 Fig. 28. Primer Memorando (Texto 1) ............................................................................................57 Fig. 29. Segundo Memorando (Texto 2).........................................................................................57 Fig. 30. Parte de Texto Largo en PostScript (Texto 3) .............................................................58 Fig. 31. Comparación Binaria..............................................................................................................60 8 INTRODUCCION El ocultamiento y la protección de la información, siempre será un tema de interés desde nivel personal hasta masivo, refiriéndonos a un interés por gobiernos o milicia; así para la parte que involucra el ocultamiento o protección como se menciona en la hipótesis y en base a la premisa que las necesidades de protección, se tienen diferentes soluciones, estas soluciones son varias, sin embargo estudiamos una que puede presentarse comúnmente en el medio computacional y particularmente en un tratamiento especifico a la forma de utilizar textos en formato electrónico PostScript y en estos su capacidad de especificar con alta precisión ubicaciones de letras en un documento electrónico de esa naturaleza y así aprovechar dicha característica para poder ocultar información ante una lectura al documento electrónico PostScript final. En el desarrollo de programas que involucren al computo, generalmente se ocupan variadas metodologías de ocultamiento así que en este trabajo nos ocuparemos de utilizar Esteganografía con texto para formatos de impresión electrónica por medio de PostScript, definiendo mas adelante algunos temas, problemas y delimitaciones para alcanzar los objetivos de este proyecto. 9 CAPITULO 1 HIPOTESIS La Esteganografía oferta muy variadas y efectivas formas de proteger y ocultar información o datos; con esta disciplina se han desarrollado muy diferentes maneras para trasportar información en determinado medio con mas de lo que se pueda pensar en una primera vista hacia dicha representación. Lao anterior se ha desarrollado desde tiempos remotos hasta nuestros días, han existido muchas técnicas diferentes aún cuando se requiera ocultar el mismo tipo de información, un ejemplo; si se deseaba ocultar un mensaje de texto se logra por medio de micro puntos señalando una letra dentro de un texto para formar una oración, otro ejemplo esta en que se rapaba a una persona de manera que se perdiera de vista el mensaje entre el resto del cabello; siempre cumpliendo la finalidad de poder pasa alguna información inadvertida por demás medios o personas que estén al tanto de poder sospechar o percatarse de que se transmite información importante. Con lo anterior se cumple la finalidad original de la Esteganografía, que es ocultar información en un medio, a manera de que no levante sospecha alguna de que existe mas información de la que se observa a simple vista. En el transcurrir del tiempo y el avance de la tecnología el ser humano se ha apoyado de su ingenio para mezclar, usar y desarrollar nuevas formas de ocultar información. Actualmente el uso de la computadora ha facilitado en gran media el ocultar información en datos, estos datos pueden representar alguna información diferente entre una y/o otra persona, siendo así que se tiene una gran capacidad de enmascaramiento de información en estos medios digitales logrando transportar mas información de lo que parece, hoy en día se ha hecho uso de imágenes, sonido y video principalmente, sin descartar al texto para ocultar información, sin embargo en este ultimo medio (el Texto plano) al usarse, se ha requerido de bastante cantidad de texto para transportar determinada cantidad de algún otro contenido, lo que hace variar según la complejidad de los algoritmos utilizados resultando por ahora los mejores en desarrollos sobre ocultamiento en texto a los proyectos privados. Con lo anterior dicho acerca de la información oculta; dentro de este trabajo nos enfocamos a desarrollar una forma de lograr mayor cantidad de información transportada mediante otro texto, este texto que en un formato electrónico debe poderse leer la misma información que la fuente original, que es un texto plano y ser transportando; a pesar de que el formato electrónico final sea mas grande para almacenamiento en disco, esto ocurrirá por respetar determinada estructura del lenguaje seleccionado que en este desarrollo será PostScript. 10 OBJETIVO Con fundamento en la Esteganografía se tendrá una implementación en Software para ocultación y protección de información de texto en texto, representado por medio de un formato electrónico de visualización de documentos en pantalla y dispositivos de impresión conocido como PostScript, que debe ser capaz ademas de poder mostrar en pantalla un texto predefinido, debe poder transportar determinada cantidad de información oculta y finalmente esta implementación debe ser capaz de extraer la información que se haya logrado ocultar en este medio electrónico. La implementación debe tener finalmente dos módulos específicos y dedicados a su tarea correspondiente; la generación y extracción de la información oculta respectivamente. Ambas partes, la generación y la extracción deben satisfacer las siguientes características: • • • • Ejecutarse sobre línea de comandos. Aceptar parámetros de trabajo. El código fuente debe ser portable a mas Sistemas Operativos. El trabajo de cada modulo debe ser veloz. Particularmente y adicionalmente la implementación encargada de generar el archivo debe: • • • • Tomar uno o mas archivos especificados en una ruta como fuentes para en estos ocultar otra información en un formato electrónico PostScript por cada archivo de texto localizado. Tomar un archivo especifico para ocultar en los archivos anteriormente señalados. Generar el formato PostScript que contiene la información oculta, visualizando otra originalmente especificada. Tomar valores básicos para visualización del formato final en pantalla. Para la implementación de la Extracción se debe tener: • • La capacidad de especificarse el archivo PostScript que contiene la información Oculta. El archivo que contendrá la información que se recupere del archivo PostScript que anteriormente se ha especificado. 11 PLANTEAMIENTO DEL PROBLEMA Actualmente existen muchas formas de ocultar y proteger información de muy variados tipos, desde mensajes hasta contenido multimedia, estas formas se derivan de dos grandes ramos, la Criptografía y la Esteganografía. Básicamente el ocultamiento y por supuesto la protección de la información, son el objetivo de ambas disciplinas con determinada información, manteniendo la posibilidad al final de un proceso de tener una recuperación de determinada información para que los datos sensibles sean reconocidos o reconstruidos por algún destinatario final; una y otra utilizan técnicas diferentes de manejar dichas protecciones; cada una con sus propias características defienden metas particulares de prestaciones. Es claro que ambas disciplinas han crecido y tienen sus origenes desde mucho tiempo atrás, pero siempre con una marcada diferencia que crea el parte aguas de sus usos, esta diferencia radica básicamente en estilo o forma visual final que pueden tener, por ejemplo para manejar textos, la frase: “Luego de el nombre de usuario de escribe la contraseña.” Cada que observamos una frase común como la anterior, que tiene un sentido como oración y que también podría no tener algún valor para mas, por la misma naturaleza de la misma fácilmente tenderíamos a menospreciarle y perderle interés de análisis. Aplicando un método Criptográfico para proteger la oración anterior, es normal observar una cadena de texto similar a la siguiente: “NjfKwoHJFLsfsdf fkjslfk .kjeoejsf*ç`¡’sdfdfç+sdf’¡’´ñ+çSFeRFffgDVBTfgH” Observar la cadena anterior, generaría muchas ideas acerca de lo que pudiera esconder, que bien podría ser cualquier cosa, por lo que se levanta una sospecha inmediata y se puede aplicar un tratamiento inverso a manera de atacar el sistema de protección y tratar de revelar la información. Situación que se esquiva en la Esteganografía, pues ademas de la comparación visual con las oraciones que se ha presentado entre las disciplinas de Esteganografía y Criptografía, también acabamos de tener frente a nosotros un ejemplo de Esteganografía aplicada; pues se ha transmitido el texto “ABELCANO” dado que en los párrafos anteriores incluyendo este se toma cada letra inicial incluyendo las oraciónes de ejemplo. 12 En base a lo anterior y en el caso de aplicar la particularidad de no levantar sospecha sobre el envío o protección de mas información ademas de la que se logra ver y/o hasta cierto punto distinguir entre que es algún criptograma o algo que pretende a simple vista ocultar algo otro, o también que aparentemente no es de lo que nos interese sospechar, se tiene a la Esteganografía como solución. La Esteganografía ha sido utilizada desde hace tiempos muy remotos y de muy variadas formas, por mencionar una manera, cuenta una historia de un rey que deseaba trasmitir información hacia un destino lejano y con muchos espías hacia su reino, se le ocurrió rapar a sus súbditos en algunas partes y formas de sus cabezas, esperar a que el resto del cabello cubriera lo suficiente el mensaje y enviarlos para que el mensaje pasara desapercibido hasta llegar a su destino y pudiera ser observando. Pero existe una variante muy particular de uso desde tiempos anteriores hasta actuales, esta es relacionada con el texto que oculta otro texto, estos mensajes utilizando el texto como medio de transporte para ocultar y proteger información han resultado un medio que esta caracterizado por transportar poca información en comparación a los demás métodos, debido a que se tienen que especificar diferentes y entre textos ocasionalmente distantes características, así como formas de recuperar el mensaje, es decir que se han hecho por ejemplo una recuperación de texto oculto cada número de caracteres predeterminados o cada que se cumpla una condición, por ejemplo cada letra mayúscula, cada después de una coma o punto etc. La poca cantidad de transporte de información oculta comúnmente obtenida en ocultar texto en texto, representa un gran problema para poder transportar un texto considerable por medio de otro texto, esto es debido a que a pesar de poder cambiar algunos bits que conformen un segmento de información por otros bits que representen otra información y que con este cambio no se note un cambio visual considerable en multimedios (Comúnmente conocido como LSB ‐ “Less Significant Bit”), el caso de bits en texto es totalmente diferente ya que al cambiar un bit de algún carácter lo convierte en otro y genera una gran diferencia y tentativamente puede llegar a considerarse posteriormente ante la vista de alguien mas como un criptograma. Al complicarse un cambio LSB en un texto y descartarlo para considerar letras a partir de referencias, donde estas se pueden ser tomadas cada determinada distancia entre textos, resulta en requerir gran cantidad de texto para trasportar texto de tamaños pequeños, ejemplo de ello puede ser el tomar solo letras después de puntos o comas por ejemplo hasta formar una oración con sentido. Actualmente se han desarrollado mejores y mas completos interpretes de formatos electrónicos que cuentan con grandes capacidades de impresión en papel como en pantalla y dispositivos de impresión, estos programas permiten gran control y conservación del formato que se diseñe en determinado programa para poder pórtalo a otros dispositivos o equipos compatibles y finalmente visualizarlo de la misma manera en que se han guardado, ejemplo de estos programas son todos aquellas 13 aplicaciones de procesamiento de texto, calculo o presentaciones en pantalla, ademas de estos existen también sintaxis y lenguajes completos de programación como el XML y el PostScript, el cual posee una versatibilidad de usos y de sintaxis a manera de alcanzar una impresión en pantalla o en papel muy personalizada y completa conforme a textos y vectores conservando esta presentación en diferentes sistemas operativos bajo un estándar de representación. En así que en este trabajo aprovecharemos la potencia de generación de impresiones del PostScript para poder personalizar un texto a manera de que porte otro de gran cantidad en texto comparada con el texto inicial, hasta medidas cercanas a la misma cantidad de información del texto portador, debido a la manera en la que se interpretarán los datos de un texto que se dese ocultar en el documento electrónico de PostScript. Lo anterior nos brinda la oportunidad de ofertar una opción mas completa a la mayoría de las aplicaciones de Esteganografía con formatos de documentos de texto electrónicos que sean portadores de alguna información adicional oculta. DELIMITACIÓN El manejo de texto como tal para poder ocultar otro texto, ocasiona generalmente textos portadores de gran tamaño, esto debido a las técnicas esteganograficas que se apliquen a la hora de ocultar y recuperar dicha información, la esteganografía presenta mucha flexibilidad y esta es generada por las formas en que las tome quien las aplique, es decir lejos de ser estrictamente una ciencia, puede perfilarse como un arte, gracias a que puede ser tan variante como el creador entienda y personalice un método esteganografico. La forma que usaremos para esteganografíar un texto plano se basa en personalizar distancias entre caracteres dentro de un documento electrónico de PostScript, y es en las variaciones de estos espacios en las que se ocultara información aprovechando que estas diferencias tan pequeñas son imperceptibles al ojo humano dado que entre los espacios predeterminados y los nuevos calculados para los caracteres del texto, no debe existir una diferencia visible. Tal es que al aplicarla nos generara ciertas opciones como poder modificar el aspecto visual o conservarlo como esta en el archivo de texto fuente, para que dentro de estos cambios y aspectos finales, ademas de adherir texto oculto el adicionar un formato visual mas completo, el cual será justificar el texto y especificar algunas distancias de margenes, espacios entre líneas y tamaño de fuente para el documento electrónico. 14 En este trabajo, se usarán documentos en archivos de texto plano, estos serán transportados al formato de impresión en el lenguaje PostScript cambiando su aspecto de texto plano en archivo TXT a un formato justificado y espaciado con una fuente Arial en el lenguaje PostScript; se ha escogido este procedimiento para ofrecer una transformación del formato de la información que se tiene, sin cambiar el sentido de la lectura y en este proceso incluir otra información y conservar la lectura idéntica entre el archivo original fuente y el generado en PostScript, lo que finalmente entrega un procedimiento de esteganografía de texto para otro texto con gran capacidad de transporte para el mensaje oculto. Los archivos de texto que tomaremos serán texto planos, es decir que deben de tener el texto de manera simple y una codificación Occidental (Mac OS Roman). ESQUEMA El trabajo es descrito en tres bloques, como sigue: • Lenguaje • Medios • Capacidades Desarollo • Conjunto de Pruebas • Modi~icaciones • MOS • Sintaxis P.S. • Ocultamiento • Recuperación Esteganogra~ia Pruebas Fig. 1. Bloques de Desarrollo 15 Cada bloque es una serie de propuestas, delimitaciones y mejoras a ideas iniciales. El primer bloque se conforma de la selección del lenguaje a utilizar para generar el archivo que tendrá la información oculta que será el PostScript, así como los medios que se utilizaran para formar una estructura de transporte de información oculta, también se selecciona el lenguaje de desarrollo, tipos de archivos a tomar, en el caso archivos de texto. Para el segundo bloque de desarrollo, se escoge la sintaxis que nos convenga para poder elaborar un archivo PostScript. tanto como se desarrollan los dos módulos principales del proyecto, siendo el primero un programa sobre la línea de comando que lleve a acabo el ocultamiento de la información de un archivo de texto sobre otro texto presentado en formato de PostScript, tanto como el desarrollo al modulo que nos ayudara a poder recuperar un mensaje oculto desde un archivo PostScript previamente generado. Finalmente la parte de generación de pruebas tanto impresas como en pantalla que nos permite saber en base a una muestra de población que se le aplica una serie preguntas a responder en base a tres pares de documentos impresos diferentes, donde cada par esta conformado de un archivo que posee información oculta y de otro que no la tiene, estas pruebas son mayormente conocidas como pruebas MOS y describen el nivel de aceptación de un evento propuesto a la sociedad, en este caso de que no existe diferencia entre las impresiones cuando en verdad la hay, pero también no hay percepción de la existencia de información oculta, que es uno de los objetivos del proyecto. ESTADO DEL ARTE El campo de la esteganografía, actualmente; se perfila hacia el uso de medios electrónicos, en la mayoría de los casos, esto por la popularidad del medio y la facilidad de difusión tanto como la flexibilidad que estos medios electrónicos informáticos pueden llegar a proporcionar o en todo caso según la creatividad del autor para ocultar con ellos información o datos. Actualmente existen mas del centenar de aplicaciones de esteganografía para trabajar de forma informática, es decir por medio de programas para equipo de computo, independiente de lo que pueda existir en otros medios como papel, perforaciones o tintas especiales. El uso de medios electrónicos para el ocultamiento y/o protección de la información, tiene actualmente gran auge cuando estos medios son sustanciosos en sus capacidades y características propias de uso y manipulación, es decir estos recursos son muy populares y utilizables generalmente por tener un ¨tamaño¨ (Informaticamente hablando) considerable, por ejemplo videos, imágenes sonidos y formatos de impresión. 16 En base a lo anterior y requiriendo conocer la oferta actual, se tiene la siguiente recopilación en el estudio del arte relacionado con los programas hablando de Software tengan un objetivo de esteganografía. Steganopic 0.1 (Windows) Programa de esteganografía, que esconde textos en imágenes, sin cambiar su apariencia. Soporta solamente el formato GIF. Cloak 7.0 (Windows) Programa de esteganografía que se utiliza para encriptar y ocultar archivos dentro de imágenes BMP. Utiliza métodos avanzados para proteger los archivos. Incluye los algoritmos de encriptación Cloak−128, Blowfish y Mercury. CryptoMX 1.1 (Win Mac Lin) Colección de herramientas de encriptación, esteganografía y conversión. Trabaja en conjunto con el navegador IE, Netscape, Mozilla y browsers Javascript. Esta realiza esteganografía de texto con texto pero genera un texto aleatorio del que extrae posteriormente la información. Dound’s Steganography 1.6 (Windows) Permite al usuario, con una simple clave, codificar y descodificar mensajes desde, o hacia, un archivo de imagen. Es muy fácil y prácticamente no se ve la diferencia entre la imagen original y la codificada. Tiene una imagen simple para probar. Hip 2.0 (Windows) Es un programa que te permite esconder archivos dentro de bitmaps, utilizando una contraseña. Da la impresión de que las figuras son normales. UnderMP3Cover 1.1 (Linux) Herramienta de esteganografía en archivos .mp3, que permite escribir y leer mensajes escondidos dentro de archivos con esta extensión, sin crear ninguna diferencia en el sonido. 17 Hide In Picture 2.1 (Windows) Hide In Picture (HIP) es un programa de esteganografía. Permite "esconder" cualquier tipo de archivo adentro de una imagen bitmap (soporta GIF y BMP). La imagen luce como una foto normal, así otra persona no puede sospechar que contiene datos ocultos. S−Tools (Windows) Herramienta que permite guardar texto dentro de imágenes. Wodax 1.2 (Windows) Permite ocultar ficheros de texto plano en imágenes PNG utilizando la técnica "esteganográfica" de Inserción en el Bit Menos Significativo" (aunque realmente usaba el par de bits menos significativos) Absolute Chaos 3.8 (Windows) Permite encriptar cualquier archivo o carpeta de la computadora y posteriormente ocultarlo en un fichero gif, doc, rtf... o cualquier otro. Hide In Picture 2.1 (Windows) Permite "esconder" cualquier tipo de archivo adentro de una imagen bitmap (soporta GIF y BMP). La imagen luce como una foto normal. MP3Stego (Windows, Linux) MP3Stego, es una herramienta que esconde datos en archivos MP3. El procedimiento consiste en tener un archivo de texto con uno .WAV, para ser trasformado en formato MP3. El problema es que para esconder datos de cualquier tamaño se necesita un archivo de un tamaño proporcional. Ejemplo: para esconder un archivo de 5 bytes, se necesita un archivo WAV de aprox.627kB. Como resultado, el tamaño del archivo compreso en MP3 fue 57Kb. Invisible Secret 4 (Windows) Codifica datos y archivos para mantenerlos a salvo o para transferirlos de forma segura a través de Internet, sino que también los esconde en lugares que superficialmente parecen totalmente inocentes, como archivos de imagenes, de sonidos o paginas Web. 18 InvisibleInk (Windows) InvisibleInk es un programa de esteganografía intuitivo codificado en C# que coloca texto dentro de un archivo de imagen .bmp. El texto puede se fácilmente encriptado/desencriptado utilizando el algoritmo Rijndael con una clave de 256 bytes generada con la función sha256. Steganography (Windows) Steganography usa técnicas de ocultación de datos digitales (esteganografía) para esconder ficheros y mensajes dentro de otros ficheros (portadores) como ficheros de imagen o sonido. Esto te permite cifrar información sensible, mientras que al mismo tiempo la escondes en un fichero que no parece sospechoso, de forma que nadie sepa que hay información cifrada. Hermetic Stego (Windows) Hermetic Stego es un programa esteganografico que permite cifrar y esconder un archivo de cualquier tamaño entre uno o más archivos de imagen BMP, con o sin el uso de una clave stego/ciframiento, de manera que la presencia del archivo es indetectable, aún para programas forensicos que utilizan métodos estadísticos, y si se utiliza una clave stego de un usuario especifico, entonces el archivo solo puede ser extraído por alguien, usando el programa, que conoce la clave stego. BitCrypt (Windows) BitCrypt es un original codificador esteganografico para la comunidad de Inteligencia y otros por el estilo. El programa le permite al usuario almacenar cualquier mensaje de texto de manera cifrada que a su vez es ocultada dentro de una imagen especificada por el usuario. El texto es codificado con uno de los algoritmos de cifrado más robustos con el objeto de mejorar el nivel de seguridad. Bon Kyu Bon 1.1.3011 (Windows) Permite ocultar un fichero o mensaje dentro de otro archivo. Con Bon Kyu Bon se puede ocultar un documento importante o un mensaje secreto dentro de una inocente fotografía. Sólo se podrá descubrir el mensaje o documento con la clave o fichero llave correctos. Bon Kyu Bon soporta los siguientes formatos: DLL, EXE, IL, BMP, TIF, TIFF, PNG, GIF, WAV, MID 19 SteganoG 1.21 (Windows) Permite ocultar toda clase de ficheros tras una imagen digital. Así, cualquiera que abra el documento cifrado verá una inocente fotografía, aunque detrás se esconderá un documento secreto. SteganoG es muy fácil de utilizar. Sólo se escoge la imagen‐ señuelo y el archivo a ocultar. Además, cuando se configure la contraseña indicará si es suficientemente segura. SteganoG soporta los siguientes formatos: RAW, BMP, DIB PicCrypt 0.3 (Windows) Es una herramienta de cifrado y protección de ficheros mediante esteganografía, en este caso usando imágenes. Se selecciona el tamaño de la imagen, el archivo a esconder dentro, una contraseña si desea aumentar todavía más la seguridad, y listo. PicCrypt es muy sencillo y no necesita configurar nada. Lamentablemente, para recuperar el archivo cifrado se necesita usar PicCrypt. P2Stego 1.0.0 (Windows) P2Stego es capaz de insertar mensajes de texto en una imagen BMP de 24 bits. Sólo hay que elegir el fichero, introducir una palabra clave y el mensaje en sí. Al pulsar Hide message, P2Stego producirá una copia exacta de la imagen original. Para descubrir el texto se tiene a disposición la pestaña Reveal, en la se podrá revelar el contenido oculto usando la misma contraseña. P2Stego presentará un mensaje de error genérico en caso de introducir una clave errónea o usar una imagen no cifrada. P2Stego es una aplicación esteganográfica con importantes limitaciones. No se puede configurar y sólo permite insertar mensajes en imágenes BMP de 24 bits. Aún así, es una prueba de concepto interesante. P2Stego soporta los siguientes formatos: BMP (24 bits) Nota sobre P2Stego: Editar o convertir una imagen modificada por P2Stego hará que se pierda el mensaje oculto Xiao Steganography 2.6.1 (Windows) Se elige la imagen o fichero de sonido donde se ocultará la información, se selecciona los ficheros que quieres ocultar y ajusta después las opciones de configuración necesarias: algoritmo de encriptación, contraseña, etc. 20 El resultado es una imagen o fichero de sonido idéntico al original, sólo que en su interior se oculta un mensaje que sólo el destinatario, con Xiao Steganography y sabiendo la contraseña correspondiente, podrá descifrar. Cambios recientes en Xiao Steganography: Puede adjuntar cualquier tipo de archivo solo limitado por el tamaño de la imagen que cargara los archivos, agregado un modulo de seguridad, Encripta / Desencripta con algoritmos RC2, RC4, DES, Triple DES , Triple Des 112 y Hashing MD2, MD4, MD5, SHA a través de la protección de clave secreta. ByteShelter 1 (Windows) ByteShelter es un sencillo programa con el que se puede ocultar un texto determinado dentro de un fichero de texto enriquecido (RTF). De esta forma, el documento RTF mantiene exactamente el mismo aspecto, antes y después de incluir el texto oculto. El programa funciona de la siguiente manera: Copiar el texto RTF donde se ocultará el mensaje directamente desde el Portapapeles. Luego se escribe el mensaje secreto, y se vuelve a guardar el texto RTF y finalmente cópiarlo de nuevo al Portapapeles. A partir de ese momento, se puede incluir en un mensaje de correo electrónico o en un DOC, y el receptor deberá usar ByteShelter (y por supuesto, introducir la correspondiente contraseña) para poder acceder al mensaje oculto en el texto RTF. Digital Identity 1.0.16 (Windows) Digital Identity gestiona contraseñas manteniéndolas en un lugar seguro, a salvo de ojos indiscretos, protegidas mediante un nombre de usuario y contraseña. Para mayor seguridad, el programa tiene soporte para codificación de ficheros y de esteganografía. Puede codificar contraseñas dentro de imágenes. La imagen conserva un aspecto totalmente normal y nada hace pensar que oculta contraseñas en su interior. El programa permite tanto encriptar como desencriptar contraseñas dentro de imágenes. También incluye utilidades de generación de claves, control de su fecha de caducidad y evaluación de su nivel de seguridad. 21 HIP (Hide In Picture) 2.1 (Windows) Oculta un fichero dentro de una imagen en formato BMP, de forma que pase totalmente desapercibida. Se puede ocultar cualquier tipo de fichero, y la imagen no se altera en absoluto, de forma que nadie sospechará que ese inocente gráfico BMP oculta un fichero secreto en su interior. Los datos quedan protegidos mediante contraseña, y puedes elegir entre dos algoritmos de encriptación. Secure Share 1.0 (Windows) permite "esconder" ficheros cifrados dentro de una imagen, que sólo se pueden descodificar mediante el correspondiente programa. El programa utiliza el algoritmo de encriptación Blowfish para codificar el archivo, y después lo oculta dentro de un gráfico GIF. La imagen tiene un aspecto totalmente normal y no se diferencia en nada de un GIF que no tenga información en su interior. El archivo además se puede proteger mediante contraseña. Después sólo tienes que enviar el archivo por e‐mail, FTP o como quieras, con la seguridad de que nadie podrá leer la información codificada en el mismo. Eso sí, el destinatario del mensaje debe tener Secure Share para poder descifrar el GIF. StegHide (Windows, Linux) Steghide es un programa de estenografía que permite ocultar datos en varios tipos de imagen y archivos de audio. Este Programa esta liberado bajo la licencia GPL por lo que se tiene acceso al código fuente y dispone de versiones para Windows y GNU/Linux. AdaStegano (Windows, Linux) AdaStegano permite ocultar cualquier tipo de fichero en imágenes bitmap de 24bpp, de forma que para una tercera persona no sepa que esa imagen contiene otro archivo. A partir de una contraseña definida por el usuario, se ocultan los datos en un orden aleatorio; sin esa contraseña, es casi imposible siquiera “ver” que hay un fichero oculto en su interior. Este software esta programado enteramente en el lenguaje Ada95 y liberado bajo licencia GPL, por lo que se puede bajar también su código fuente y funciona para GNU Linux y MS Windows. A diferencia del StegHide, el AdaSteganos cuenta con una interfase gráfica y esta totalmente en español. 22 CryptArkan (Windows) La principal característica de CryptArkan es ocultar archivos cifrados dentro de archivos de audio wav con compresión PCM de 16 bits. Los archivos ocultos Irán protegidos mediante contraseña. Ademas de los archivos de audio, es posible ocultar y cifrar texto dentro de una imagen bmp como la mayor parte de programas de esteganografía. Xidie Security Suite (Windows) Xidie Security Suite es una de las aplicaciones lideres en cifrado y esteganografía e incluye funcionalidades como: compresión de archivos (incluyendo el formato Zip), cifrado, esteganografía con 40 tipos de portadores, borrado seguro de archivos y otros componentes que le ayudan a proteger los archivos y carpetas del PC y almacenarlos de forma segura. Puede proteger un archivo o múltiples archivos con solo un clic, directamente desde el Explorador de archivos de Windows. OutGuess (Unix Linux) Permite la inserción de información oculta en los bits de redundancia de fuentes de datos. La naturaleza de la fuente de datos es irrelevante para el núcleo de OutGuess. El programa se basa en los datos de controladores específicos que va a extraer bits de redundancia y escribir de nuevo después de la modificación. En esta versión el PNM y formatos de imagen JPEG son compatibles. En los siguientes párrafos, las imágenes se utiliza como ejemplo concreto de los objetos de datos, aunque OutGuess puede utilizar cualquier tipo de datos, siempre que cuenten con un controlador. Camera / Shy (Windows) Automáticamente busca y ofrece contenido descodificado directamente desde la Web. Es un stand‐alone, Internet Explorer, basada en el navegador que no deja rastro en el sistema del usuario y ha mejorado la seguridad. JPHIDE y JPSEEK (Windows) Permiten ocultar un archivo en una imagen jpeg. El objetivo de diseño no era simplemente ocultar un archivo, sino de hacerlo de tal manera que es imposible probar que el archivo de host contiene un archivo oculto. Dada una imagen visual típica, una tasa de inserción baja (menos del 5%) y la ausencia del archivo original, no es posible concluir con certeza que vale la pena que el archivo de host contiene datos insertados. Como el porcentaje de inserción aumenta la naturaleza estadística de los coeficientes de jpeg difiere de "normal" en la medida en que aumenta la sospecha. Por encima de 15% de los efectos comienzan a ser visibles a simple vista. Por supuesto, 23 algunas imágenes son mucho mejores que otros cuando se utiliza un archivo de host ‐ un montón de detalle es bueno. Un cielo azul sin nubes en un paraíso de esquí cubierta de nieve es malo. Una cascada en un bosque es probablemente ideal. Hydan (Unix Linux Windows) Oculta un mensaje en un ejecutable. Se explota la redundancia en la instrucción de la i386 establecidos por la definición de conjuntos de instrucciones funcionalmente equivalentes. A continuación, codifica la información en código de máquina, utilizando las instrucciones de cada juego. El archivo ejecutable se mantiene sin cambios. El mensaje es cifrado Blowfish con una frase de contraseña proporcionada por el usuario antes de ser incorporados. Según el campo observado en Software para la esteganografía, podemos observar como la mayoría de lo programas, independientemente de la plataforma en que se estén ejecutando, prefieren utilizar medios para portar información oculta, de gran capacidad en relación a su contenido y tamaño informático; esto debido a la facilidad que esta cantidad de información ofrece para poder ser reemplazada sin que se note un diferencia considerablemente visible en el resultado final. Lo anterior nos dice sin duda alguna que la popularidad de ocultar información en imágenes o sonido y seguramente en video mas adelante por lo que este perfila en e su cantidad de información se desenvuelven y crecen con mayor velocidad que otros medios de menor cantidad de información, por lo que en un futuro seria mas probable tomar en cuenta para sospechar estos medios que los recursos mas livianos en un tamaño informático, por ejemplo textos o formatos de impresión electrónica. Pero con base a este estudio del arte nos deja sin duda de que el recurso necesario para poder ocultar información termina siendo el recurso necesario para camuflar información, así que es siempre necesario incrementar o tener gran cantidad de información para dentro de ella colocar otra determina información que parezca perteneciente a la propia portadora, sin embargo y obviamente sin perder el objetivo de la esteganografía, esta ultima sea un mensaje o información oculta. En base a las premisas que nos ofrecen los programas y que la elaboración de estos en su gran mayoría se enfocan a el trabajo de información oculta con ayuda de recursos multimedia de gran capacidad, el reto que se tiene es ocultar información con menor cantidad de información, así este desarrollo toma el reto de ocultar texto pero en otro texto y respetando la forma de tener un incremento en el medio portador que ocultara la información; este medio serán los archivos de impresión electrónica, conocidos como archivos PostScript. 24 CAPITULO 2 POSTSCRIPT El PostScript, es un lenguaje de programación para presentar información en texto y/o vectores para, estos últimos para generar imagenes en la computadora y en impresoras que soporten este lenguaje, tal es que este lenguaje tiene ya una larga trayectoria de uso y desarrollo; ha tenido ya varias versiones y con ellas diferentes y mejores usos como también aplicaciones, por ejemplo, en las primeras versiones no es posible representar imágenes como en las ultimas versiones, sin embargo cabe mencionar que en este trabajo no nos enfocaremos al tratamiento de imágenes. Es importante de tal manera conocer que la principal aplicación del PostScript es describir la apariencia de texto, formas graficas e imagenes. Esta descripción de alto nivel sobre texto e imagen es independiente del dispositivo grafico a usar (pantalla grafica o impresora). Para lograr las características anteriores entre otras, el lenguaje PostScript hace uso de un “interprete”, quien tendrá el papel de cambiar las líneas de código por una representación en la pantalla involucrando textos y/o imágenes. PostScript puede ser visto desde los siguientes puntos de vista: • • • • Un lenguaje de programación de propósito general con primitivas graficas incorporadas. Un lenguaje de descripción de pagina con cualidades de programación. Un sistema interactivo para controlar dispositivos de salida raster (pantallas e impresoras) Un formato para intercambio El lenguaje PostScript (PS) puede interactuar con Dispositivos de Salida Raster (DSR) tales como impresoras láser, matriz de punto, de inyección de tinta y todo tipo de pantallas. Una imagen impresa o desplegada a un DSR es un arreglo rectangular de puntos llamados pixeles que pueden ser direccionados individualmente. Por ejemplo en DSR blanco y negro cada pixel puede ser blanco o negro. En otros DSR mas avanzados estos pixeles pueden ser tonalidades de grises o colores. Con esta técnica se pueden reproducir complejas imagenes o texto dependiendo de la resolución del DSR. 25 Lenguajes de Descripción de Pagina Teóricamente o comúnmente se podría pensar que cualquier aplicación (como un procesador de texto por ejemplo) podría hacer una descripción de pagina como un arreglo de paginas, cada una de estas siendo un arreglo de pixeles. Sin embargo una descripción de este tipo seria dependiente del dispositivo y por lo tanto enorme para documentos grandes. Un lenguaje de descripción de pagina debe ser suficientemente compacto para almacenamiento y transmisión, ademas de ser independiente del dispositivo. Estas características de portabilidad e independencia para un archivo a un dispositivo se pueden lograr si el lenguaje logra describir las paginas en términos de entidades graficas abstractas de alto nivel en lugar de un arreglo de pixeles. Es en el DSR donde se genera el arreglo de pixeles a través del proceso llamado “Scan Conversion”, Este proceso consiste en que dada una descripción PS en este caso para la entidad grafica, se determinan que pixeles se deben ajustar y que valor se les debe asignar para encontrar la mejor representación posible de la entidad a la resolución del DSR. Estructura del Lenguaje Una descripción de pagina PS bien estructurada consiste en un prologo y un script. El prologo es un conjunto de procedimientos a usar y se acostumbra a ponerlo en el comienzo del archivo. El script es la descripción de los elementos de las paginas con ayuda de los procedimientos del prologo. Esto ayuda a que la descripción de la pagina sea mas eficiente y compacta. Por ejemplo en el prologo se puede definir: /ms {moveto show} bind ref Y en el script se puede llamar a este procedimiento de la siguiente forma: (texto cualquiera aquí) 100 200 ms Así el script de un documento a imprimir por ejemplo, consiste típicamente de una secuencia de paginas separadas. La descripción de cada pagina puede usar los procedimientos del prologo pero debe ser independiente de las demás paginas del script. 26 Programación en PostScript PostScript, lejos de ser solo una estructura de representación de impresiones en pantalla o impresoras de texto y de imágenes, es un muy completo lenguaje de programación que nos permite llevar acabo diferentes tareas, tales como calculo de operaciones matemáticas y resolución de problemas computables, tal es el canso entonces que PostScript usa notación postfija. En una operación los operandos van después de los operadores. Ej: “2 3 add”. El interprete PS manipula entidades llamados Objetos PostScript (OP). Algunos OP son datos (números, booleanos, strings) mientras que otros son elementos de programa a ser ejecutados (nombres, operadores y procedimientos). El interprete opera ejecutando secuencia de OP. El efecto de la ejecución de un OP depende del tipo de este, sus atributos y su valor. Por ejemplo la ejecución de un OP numero provoca que el interprete ponga una copia de ese objeto en la pila de operandos para posterior seguir operaciones postfijas. La ejecución de un nombre provoca que el interprete busque su valor en el diccionario, lo obtenga y ejecute ese valor asociado. La ejecución de un objeto operador provoca que el interprete realice una acción que posee incorporada, tal como la suma o el pintado de caracteres en memoria. El intérprete PS consume un programa mediante la ejecución de cada OP que encuentra. No es necesario por tanto compilar o interpretar el programa entero de una vez para hacer algo. Existen tres codificaciones para programas PS: ASCII, binary token y secuencia de objetos binarios. ASCII es la codificación mas usada y recomendada. En la codificación ASCII los espacios en blanco separan una construcción sintáctica de otra. Uno o mas espacios son tratados como si fueran uno solo. Los caracteres tratados como espacios son los siguientes: Octal 000 011 012 014 015 040 Hex 00 09 0A 0C 0D 20 Decimal 0 9 10 12 13 32 Nombre Nulo (nul) Tab (tab) Line‐feed (LF) Form‐feed (FF) Carriage‐return (CR) Space (SP) Fig. 2. Tabla de Codificaciones 27 Los caracteres CR y LF son también llamados caracteres newline. Un CR seguido inmediatamente por un LF son tratados juntos como un solo newline. Los caracteres (,),<,>,[,],{,},/, y % son especiales. Ellos delimitan entidades sintácticas tales como strings, procedimientos, nombres literales y comentarios, sin embargo cabe señalar que por ello al enviarlos a pantalla reciben un trato especial. Un comentario en PS se forma desde un % hasta el siguiente newline no importando la existencia de cualquier carácter de por medio. Números Los números en PS pueden ser: • • • Enteros con signo: 123, ‐98, 43445, 0, +17 Reales: ‐0.002, ‐.01, 123.6e10. 1E‐5, 0.0 y Números con base (radix numbers): 8#1777, 16#FFFE, 2#1000 Si un entero excede el limite de implementación para ese tipo de dato entonces es convertido a real. Si un real excede su limite entonces un error de “limitcheck” ocurre. Los mismo anterior sucede para los radix numbers. Strings Hay 3 convenciones para definir strings: • • • Como texto literal encerrado entre ( y ) Como dato codificado hexadecimal encerrado entre < y > Como dato codificado ASCII base‐85 encerrado entre <~ y ~> (PS2) Dentro de un string el “backslash” \ se usa como carácter de escape para incluir caracteres especiales tales como : \n, \r, \t, \b, \f, \\, \(, \), \ddd. Este ultimo es código octal del carácter y sirve para poner caracteres especiales como ñ o á, ó, etc. 28 Nombres Toda construcción sintáctica compuesta de caracteres regulares y que no puede ser interpretado como numero es tratado como un objeto nombre o un nombre ejecutable. Cualquier carácter excepto delimitadores o espacios pueden formar parte de un nombre. Cuando inmediatamente delante del nombre hay un / entonces este es un nombre literal, en caso contrario es un nombre ejecutable. Arreglos Los caracteres “[“ y “]” delimitan un arreglo. Por ejemplo: “[123 /abc (xyz)]” es un objeto arreglo que contiene el entero “123”, el nombre literal “abc” y el string “xyz”. Procedimientos Los caracteres “{“ y “}” delimitan un arreglo ejecutable o procedimiento. Por ejemplo: “{add 2 div}”. Un procedimiento no es ejecutado de inmediato, sino que se pone en la pila de operandos y se ejecuta si es explícitamente invocado. Ejecución El lenguaje de programación PostScript, como se ha mencionado, trabaja con forme a evaluaciones postfijas, estas son asistidas de funcionamientos en pilas, dichas pilas son manipuladas por el interprete (IPS). El IPS maneja 4 pilas que representan el estado de ejecución de un programa PS. • • • • Pila de operandos. Mantiene los objetos PS que son operandos para una operación posterior o son el resultado de alguna operación llevada a cabo. Esta pila puede es manipulada por el programa PS. Pila diccionario. Mantiene objetos diccionario. Esta pila también es manipulada por el programa PS. Pila de ejecución. Mantiene la secuencia de objetos ejecutables a ejecutar. Esta pila es manipulada por el IPS, puede ser leída por el programa PS pero no modificada. Pila de estado grafico. La semántica de la ejecución difiere de un tipo de objeto a otro. Esta ejecución puede ser inmediata o diferida. 29 Por ejemplo: “40 60 add 2 div” 1. El IPS en este caso carga en la pila de operandos el valor entero 40. 2. Se encuentra el entero 60 y lo carga también en la pila de operandos. 3. Se encuentra “add”, se busca en la pila de diccionarios por este nombre. Se encuentra en “systemdict” y se ejecuta su acción incorporada, la suma de los dos últimos operandos de la pila de operandos. 4. Luego de llevarse a cabo tal operación se carga 100 en la pila de operandos y se eliminan los operandos anteriores 5. Luego el IPS carga 2 en la pila de operandos y ejecuta “div”, después de lo cual cargaría 50 en la pila de operandos. Esta ejecución es inmediata. Estructuras de control En PS, las estructuras de control tales como condicionales o iteraciones son llevadas a cabo por operadores que toman procedimientos como operandos. Por ejemplo: a b gt {a} {b} ifelse 1. 2. 3. 4. El interprete encuentra los nombre ejecutables “a” y “b” y los busca en la pila de diccionarios. En este caso se asumen números y se ejecutan cargándolos en la pila de operandos. El operador “gt” saca los dos operandos, los compara y pone “true” en la pila si el primero es mayor que el segundo y “false” en cualquier otro caso. Se encuentran los procedimientos {a} y {b} que se ponen en la pila de operandos. El operador “ifelse” toma tres operandos, un boolean y dos procedimientos. Se sacan estos tres operandos de la pila de operandos. Si el primer operando es “true” entonces se ejecuta {a}, en otro caso se ejecuta {b}. El resultado de este estamento es poner entonces en la pila de operandos el valor mayor entre “a” y “b”, dado que ambos procedimientos tienen aquellos números tan solo como cuerpo. 30 Los operadores de control son:1 • • • • • • if, ifelse Ejecuta un objeto incondicionalmente. for, repeat, loop y forall exit: Escapa de un loop stop: Termino prematuro, quiebra toda secuencia de ejecución. countexecstack, execstack: se usan para leer la pila de ejecución Ejemplos: % provocara poner en la pila 4 veces el string “abc” sacando previamente % los operandos 4 y el procedimiento de la pila 4 {(abc)}repeat % aquí el tope de la pila termina con el valor 4 8 4 {1 sub} repeat % equivale al codigo-C: for(i=0; i<=8; i++) proc; % si el incremento es negativo entonces el <= se cambia por un >= 0 2 8 {proc} for % lo siguiente pondra los valores 3.0, 2.5, 2.0, 1.5 y 1.0 en la pila 3 -0.5 1 {}for % en cada iteracion del for el actual valor del contador es puesto en la pila, así 0 1 4 {add} for % resultara en un 10 al final. Entre las estructuras de control, pilas y demás prestaciones que ofrece el lenguaje de PostScript podríamos detallar mas acerca del funcionamiento del lenguaje, sin embargo dado que este no es el objetivo de esta investigación, continuaremos con las actividades relacionadas al proyecto. Todo lo concerniente al lenguaje PostScript que tenga relación con el tema se desarrollara en el tiempo. 1 PostScript. Salvador Ramírez Flandes, Ideas Básicas, P. 5 31 Por ahora, es importante saber que se ha escogido el lenguaje PostScript para poder representar textos en formatos justificados, gracias a la posibilidad de especificar con detalle las separaciones entre caracteres, que es una de las características finales que se desea al finalizar un archivo PostScript, objetivo comentado anteriormente. De tal forma que según la oferta de las capacidades del PostScript, nos permitirá especificar con precisión la ubicación de cada uno de los caracteres de un texto indicado, de tal suerte que dentro de este resultado visible en un archivo PS encontremos de forma esteganografiada a la información que deseamos ocultar o proteger, esta información debe de poder ser recuperada posteriormente y esto se hará a través de la estructura de sintaxis que se termine utilizando para armar el archivo PS con distancias modificadas pero imperceptibles en comparación a las separaciones entre caracteres, que entre otras medidas que describen a un carácter se conocen como métricas. SELECCIÓN DEL LENGUAJE DE PROGRAMACIÓN El lenguaje de programación para formar este proyecto se escoge con cuidado pues debe de tener un alto grado de portabilidad y rapidez en su ejecución para los trabajos que se le asignen, tanto como la habilidad de poder escribir ficheros en el sistema de archivos donde se este ejecutando, pues estas escrituras serán los archivos que buscamos generar en este trabajo, es decir los archivos PS finales que serán capaces de portar información protegida en con ayuda de la técnica esteganografica dicha. El lenguaje de programación que se ha seleccionado es el “C”, dado que este lenguaje proporciona todos los elementos que requerimos para formar los archivos resultantes PS y posteriormente estos puedan ser desplazados hacia otro programa o modulo que se encargue de extraer la información que se ha protegido. SELECCIÓN DE MODULOS A DESARROLLAR Dado que el proyecto marca elaborar una protección esteganografica para ocultar o proteger información en forma de texto, esta debe de ser posible de recuperarse a partir de los primeros resultados que nos entregue la fase de ocultamiento, de tal manera que entre ambos programas o módulos completen un ciclo para el viaje de información de un punto a otro pasando por un medio informático, pudiendo ser memorias USB, Correos, Internet, etc, con esteganografía para proteger y brindar confidenciabilidad a la información. 32 Para alcanzar a cumplir lo anterior se ha seleccionado desarrollar dos módulos generales, estos han sido escogidos para cumplir con los anteriores planteamientos, el primero será quien se encargue del proceso de ocultar un texto en otro texto resultando este ultimo en formato electrónico PostScript, para que el segundo tenga la labor de extraer en relación este ultimo archivo creado, la información ocultada. Una vista preliminar del comportamiento será: Fig. 3. Flujo de Esteganografía Propuesto Donde el archivo PS presentará la misma información que el “Archivo de Texto” originalmente dicho, solo que adicionado el formato de justificado y será presentado con un formato y extensión PS. Ahora en relación al modulo encargado de extraer la información , este esta obligado a tomar los archivos que se generan con el procedimiento anterior, esto debido a la forma en que esta estructurado el archivo PS portador y su sintaxis interna. El detalle de cómo se extrae y almacena la información a proteger se detalla mas adelante. Fig. 4. Flujo de Extracción Propuesto La utilización de estos dos módulos es el procedimiento completo para poder proteger algún texto, visualizarlo y transportarlo con y diferentes medios hasta extraer dicha información oculta. Durante el Capitulo 3 se vera mas a detalle como es el funcionamiento de cada uno de los generadores, tanto como es que uno depende del formato entregado en los archivos PS para realizar su función de Extracción, pues ambos programas trabajan sobre las métricas entre caracteres para ocultar y extraer información. 33 CAPITULO 3 ARCHIVOS DE TEXTO Los archivos de texto plano (en inglés plain text) son aquellos que están compuestos únicamente por texto sin formato, sólo caracteres. Estos caracteres se pueden codificar de distintos modos dependiendo de la lengua usada. Algunos de los sistemas de codificación más usados son: ASCII, ISO‐8859‐1 o Latín‐1, Unicode, etc... Se les conoce también como archivos de texto llano, o texto simple, por carecer de información destinada a generar formatos (negritas, subrayado, cursivas, tamaño, etc.) y tipos de letra (por ejemplo, Arial, Times, Courier, etc.). El término texto plano proviene de una traducción literal del término inglés plain text, término que en lengua castellana significa texto simple o texto sencillo.2 En este caso se están utilizando archivos de texto plano, estos archivos están escritos en el sistema operativo donde se ha desarrollado la aplicación, este sistema operativo es el OS X 10.5, sin embargo se tiene la singularidad de que están en una codificación de texto normal Occidental MAC OS Roman. Estos archivos son compatibles en sistemas operativos Linux y Windows, presentando así una gran portabilidad al momento de aplicarles en el programas generador de PostScript. Dentro de los archivos con los que alimentaremos al generador no existe un formato establecido, pues una de las finalidades es proporcionarle uno, este será el justificado, pero de este en fuera se tomara como este conformado el archivo original, de tal manera que el archivo de texto original debe presentar la información que será la encargada de portar otra información a proteger o ocultar para llegar al formato PS. Se tiene contemplado para estos archivos, tomar líneas largas sin saltos de carro, para posteriormente ajustarlas en el formato buscado, sin embargo si se encuentran líneas con pocas palabras y estas no aplican al justificado se presentaran como están o si es necesario de ajustaran. 2 http://www.mitecnologico.com/Main/DefinicionArchivosTextoBinarios 34 ARCHIVOS POSTCRIPT PostScript es un "lenguaje de descripción de página", es decir, es un lenguaje de programación que se usa para decirle a una máquina destinada a imprimir cómo y qué debe imprimir. Un documento PostScript, en realidad, es un pequeño programa que le dice a una máquina qué, cómo y dónde imprimir, paso a paso. Los documentos PostScript se destinan a imprimirse en aparatos PostScript, es decir, en aparatos que tienen un dispositivo interno capaz de descifrar el código que reciben y convertirlo en simples puntos de impresión.3 PostScript fue inventado y desarrollado por la firma californiana Adobe hacia 1984. Apple lo adaptó en 1985 a sus impresoras láser y fue un rotundo éxito, gracias en parte a una aplicación de diseño de páginas llamada PageMaker que fabricaba la compañía Aldus. Cuando una empresa de gran solvencia en las artes gráficas, Linotype, adoptó PostScript el éxito quedó asegurado. El hecho es que PostScript no es el único Lenguaje de Descripción de Página (LDP) que existe, pero es el que ha tenido más éxito y el que se ha convertido en un estándar de las artes gráficas. Los archivos PostScript son ficheros que se atienen a la estructura del lenguaje PostScript para, usualmente, describir datos de imagen a un dispositivo de impresión "de calidad". Todo fichero PostScript tendrá un encabezamiento que lo identificará como fichero PostScript: %!PS­Adobe­3.0 y terminará con una marca de final de fichero del tipo %%EOF , %EPS grestore, %EndPhotoshop , o algo similar. Los ficheros Postcript pueden ser multipágina o de una sola página. Éstos últimos se suelen llamar ficheros "EPS" (pronúncialo "e‐pe‐ése"), del inglés Encapsulated PostScript, ("PostScript Encapsulado"). La diferencia básica es que los ficheros EPS son ficheros que se van a tratar como una única imagen (especialmente en otro programa) y que, por ello, contienen una delimitación de tamaño (que va marcada mediante el uso de la orden "BoundingBox" y la restricción de no usar la de "showpage"). La diferencia entre los ficheros PostScript a secas y los ficheros EPS es, pues, que son los primeros no encapsulados y pueden ser multipágina. 3 http://www.gusgsm.com/que_es_el_lenguaje_postscript 35 Los ficheros PostScript (del tipo que sean) pueden contener, además de masas de texto, información gráfica de dos tipos principales: Objetos vectoriales y mapas de imágenes. En claro: Dibujos de programas como Illustrator y fotos de programas como Photoshop. La complicación surge de que un dibujo vectorial puede contener a su vez uno o más "mapas de imágenes" (fotos) incrustadas en su interior, y un mapa de imágenes puede contener uno o más objetos vectoriales (trazados, en este caso). Es un poco como esas muñecas rusas que se contienen unas dentro de otras. FORMATOS COMPARATIVOS TEXTO Y POSTSCRIPT Cuando hablamos de un formato, sobre todo en esto de los textos, nos referimos a la parte visual y estética que estos textos o documentos presentan al momento de ser presentados ante un lector. Entre los formatos que se pueden presentar para los archivos de texto no se encuentra mas que el justificado a la izquierda si se pudiera considerar este como formato, dado que no se tiene un limite definido como hoja en estos archivos para hacer un salto de línea o pagina en automático, púes como se ha dicho anteriormente estos no posen alguna validación de estos tipos y por ello son considerados archivos de texto plano. Sin embargo la historia para los procesadores de palabras es diferente, estos pueden presentar una serie de manipulaciones para representar textos en la pantalla y en la impresora que por si solo el archivo de texto no posee, así la información puede obtener una apariencia mas acorde a los fines que se busquen para presentar dicho contenido; por lo que en cuanto mas formato necesite determinada información esta requerirá de programas mas elaborados y con mayores capacidades de formatear información, haciendo un incremento en varios aspectos a la estructura del archivo resultante, por ejemplo, no se tiene el mismo tamaño en bytes si se guarda un párrafo en texto plano que si se guarda el mismo párrafo en un editor de textos como Word por ejemplo. Así entonces es justificable el aumento en tamaño del archivo conforme el formato que se establezca para la información contenida en el archivo, sin embargo el tamaño de los archivos encargados de presentar determinada información esta definido del todo por formatos, es también conforme a la estructura del tipo de archivo que la trabaje, por ejemplo un archivo “doc”, “dot” “docx” etc. En este trabajo usaremos las estructuras PostScript para presentar un texto en pantalla y también se proporcionara un formato justificado al texto, esto para tener alguna presentación, sin embargo la opción de justificado no representa el mecanismo principal para ocultar información. 36 CAPITULO 4 DESARROLLO DEL GENERADOR El desarrollo del generador completo se ha elaborado en el lenguaje de programación C, esto para poder presentar mayor velocidad de trabajo en los equipos tanto como ofertar mayor portabilidad futura para el código hacia otros sistemas operativos. La compilación, desarrollo y pruebas se han llevado a cabo en el sistema operativo “OS X Versión 10.5.8” con el compilador “GCC 4.0” bajo la herramienta de desarrollo “Xcode 3.1.2” La técnica de programación ha sido modular entre los dos programas que forman el ciclo de ocultamiento – recuperación dado que la estructura interna del código fuente ha sido escrita con funciones que se encargan de labores especificas. El Programa generador, tanto como el Extractor, están diseñados para recibir parámetros, estos son el nombre de archivo de texto o la ruta de un directorio para el caso del Generador, que contienen la información que se usara como portadora y de nombre para el archivo PostScript generado al final de este proceso según corresponda al nombre del archivo o archivos encontrados y el segundo parámetro para el programa generador define que archivo de texto será ocultado en el o los portadores localizados que siempre deben ser archivos de texto plano; una apariencia final de la línea de comandos se muestra a continuación: Sintaxis: “./DirTxt2PS {Directorio o Archivo de Textos Portadores} {Archivo a Ocultar}” Fig. 5. Aspecto del generador sobre la línea de comando Donde apreciamos los parámetros al programa “DirTxt2PS”, las cadenas de texto “./DirAbel” y “Ocultar.txt”, siendo la primera un directorio donde se encuentran archivos de texto plano que serán utilizados para ocultar el contenido del archivo “Ocultar.txt” en el formato PostScript de lectura idéntica a los portadores. 37 Modo de Funcionamiento El funcionamiento del programa generador queda sujeto a las siguientes premisas al momento de ser ejecutado: • • • Tener un conjunto de archivos de textos claros o uno solo, en donde ocultaremos alguna información de texto plano. Poseer la información a ocultar o proteger en forma de texto claro para ocultarla a través del formato PostScript. Tener permisos de escritura sobre el sistema de archivos. Cumplidas las premisas y en base al flujo de la Fig 6, se obtiene un archivo resultado que contiene la información oculta del archivo descrito como Secreto y en la lectura de este archivo se visualiza la misma lectura del texto portador. Fig. 6. Flujo de Ocultación de Información Así el resultado final, visualmente será ver en el archivo PostScript la información que dicte el Archivo de texto portador y sin alguna señal visible de la información a proteger. Siendo la única diferencia entre el archivo portador y el resultado el formato del archivo; el primero será un archivo de texto plano y el final un archivo PS. Básicamente el funcionamiento interno del Generador es tomar del primer parámetro especificado y usar este valor para conocer si este indica un directorio o un archivo, para el caso de ser un directorio otro modulo dentro del programa se encarga de recuperar todos los archivos de texto contenidos en el directorio y tener una lista de estos archivos, lista para usar conjunto al segundo parámetro que se especifica, donde este es conocer el archivo en texto plano que será ocultado, aquí cabe mencionar que si se tiene una lista de archivos, la información en el archivo a ocultar será colocada en cada uno de los archivos encontrados en el directorio especificado. 38 El programa generador llevara a cabo la tarea de crear el archivo con formato PostScript en base de conocer los parámetros que se le indican, así pues la labor de convertir el archivo original o portador en un formato PostScript debe tener implícita e inmersa la función de mezclar el archivo a ocultar, esto para cumplir el objetivo del Generador y tanto así agregar un formato predefinido al resultado final en su versión PostScript, este formato esta definido por los valores siguientes: • • • • • Ancho de la Hoja Alto de la Hoja Espacio entre líneas Margen Izquierdo Margen Derecho • • • • • Margen Superior Margen Inferior Letras por Línea Mayúsculas por Línea Tamaño de Letra En base a este conjunto de parámetros sobre la línea de comandos y en ejecución del programa para el caso de los parámetros de que tendrá el archivo PostScript, se elabora una serie de procedimientos para conformar una estructura PostScript que contendrá ademas de aparentemente el texto portador en este formato, la información oculta en este archivo PS para posteriormente extraerla como se ha mencionado, con el uso de las métricas entre caracteres, por lo que es en el momento de armar el archivo resultante donde se aplicara la esteganografía que como se ha dicho es aprovechar diferencias imperceptibles para el ojo humano pero si medibles para un programa computacional y donde se pueden almacenar información. Una comparativa de los aspectos de un archivo fuente de texto con su archivo resultante en PostScript es como sigue: Fig. 7. Archivo de Texto Portador 39 Fig. 8. Archivo PostScript resultante En estas imágenes observamos la apariencia del archivo de texto que se tiene y también aunque no se muestra se tiene un archivo de texto plano para ocultar, estos archivos son usados para generar el archivo final con la apariencia del texto portador. Técnica Esteganografica La esteganografía no es una metodología ni un procedimiento establecido dado que puede tomar muchas formas según el ingenio de quien lo aplique, de esto se ha hablado anteriormente, así que en esta sección se comentara de la técnica aplicada en el trabajo y como el PostScript puede aportar gran manejo a dicha técnica seleccionada. El ocultar información como se ha dicho anteriormente depende en gran medida de tener una cantidad razonable de información para este fin, en el caso de la informática, gran cantidad de bits. Al transformar el documento de texto plano a formato PostScript este ultimo contiene mayor cantidad de información por el hecho de ser otro formato con mayores capacidades de presentación aun cuando no se tengan mas características agregadas a la información que se obtiene finalmente. 40 Entre las posibilidades comentadas para presentar información con las estructuras PostScript se había comentado acerca de una muy común (Representación de String en Texto Lineal), por ejemplo: /ms {moveto show} bind ref (texto cualquiera aquí) 100 200 ms Sin embargo este ejemplo complica poder insertar información oculta debido a la forma lineal en la que se presenta el texto con el comando PostScript, en este caso el texto que se vera en pantalla, que el que se considera como portador. Luego entonces se tiene que si se quisiera Esteganografiar con esta técnica se debería de tener alguna referencia entre el texto para indicar algún carácter oculto, esto daría como resultado requerir una gran cantidad de texto portador para transportar o ocultar una cantidad pequeña de texto. De tal forma que se tiene por elección una estructura PostScript diferente, donde se involucra una característica del texto conocida como “métricas”, esta métricas en los textos especifican las distancias que existen otras letras y entre el mismo carácter, y es así que en la estructura PostScript puede especificarse el espacio entre los caracteres que debe tener cada uno, esto ademas de permitirnos alinear un párrafo en forma justificada nos dará la pauta a poder especificar de manera muy precisa los espacios y conseguir entre esa precisión el poder incrustar mas información y es debido a que tales números tan pequeños logren ser imperceptibles a la vista humana. La siguiente imagen muestra la apariencia de las métricas en un carácter: Fig. 9. Métricas de un carácter 41 Quedando básicamente en el poder de manipulación de estos archivos PostScript las métricas que miden las distancias entre caracteres, es decir, los espacios entre los caracteres pueden llagar a definirse de manera muy precisa, tanto que al variar las ultimas unidades numéricas de presión no pueda observarse una variación entre las distancias reales y las nuevas propuestas por la modificación, terminando por ser esta la técnica esteganografica aplicada; es decir que cierta precisión entre caracteres, representa una determinada letra que corresponde a las letras del archivo a ocultar, pero estas son disfrazadas en los últimos tres dígitos numéricos de una precisión de cientos de miles de unidades a partir de punto decimal, por ejemplo, una distancia de “3.347824” frente al ojo humano no es diferente a la distancia “3.347907” y estos últimos tres dígitos “907” representan un carácter en valor ASCII para el documento de texto a ocultar, que son leídos posteriormente por el programa extractor para recuperar la información oculta, cabe mencionar que estas unidades están descritas en Pixeles. Un ejemplo visual de lo comentado como la técnica de esteganografía se muestra a continuación: Steganography Vs Steganography Fig. 10. Comparativa de Textos Donde a vista del lector no se puede observar una diferencia entre los textos y uno de ellos con su formato PostScript porta información extra y esta como se ha comentado viaja en las métricas que marcan los espacios entre los caracteres. La estructura interna del PostScript que elabora la palabra anterior es como sigue: 50.000000 742.000000 moveto (Steganography) [7.060004 4.279072 6.499374 6.499374 5.940111 6.499374 6.499374 Fig. 11. 6.499108 4.829684 ] xshow 5.940097 5.939684 6.499374 6.499374 Estructura PostScript con información Oculta 42 50.000000 742.000000 moveto (Steganography) [7.059525 4.279374 6.499374 6.499374 5.939684 6.499374 6.499374 6.499374 4.829684 ] xshow Fig. 12. 5.939684 5.939684 6.499374 6.499374 Estructura PostScript sin información Oculta Finalmente podemos observar como se puede escribir cada métrica de distancia entre caracteres para las letras que especificamos, es decir que cada una de estas métricas dicta el espacio que ocupa cada carácter. En las métricas dichas podemos observar un alto grado de precisión, estas distancias son muy precisas como para que un ojo humano pueda notar la diferencia entre ambas a la hora le leer el documento PostScript generado, Ejemplo: Fig. 13. Archivo PostScript Sin Información Oculta Fig. 14. Archivo PostScript Con Información Oculta Finalmente el “Generador” nos permite ocultar y proteger información de tipo texto con otra del mismo tipo de dato con ayuda de la Esteganografía en textos en un solo comando. 43 Fig. 15. Comando de Generación de PS con información Oculta El programa generador es entonces así el primer eslabón el proceso de ocultamiento y protección de la información que pretendemos manejar, este se encarga de ocultarla y que sea insospechable para terceras personas que participen en las lecturas de estos documentos PostScript. Mas adelante se hablara de los resultados obtenidos en una prueba MOS para medir el nivel de ocultamiento e imperceptibilidad de mas información ademas de la que se lee. DESARROLLO DEL EXTRACTOR El Software generador cumple con su trabajo y el ciclo se completa solo cuando esta información oculta previamente puede volverse a poseer, es aquí cuando el programa “Extractor” cumple con finar el ciclo de transporte y de protección de la información. El programa Extractor requiere de un archivo PostScript previamente armado, este archivo debe de contener la estructura interna que se ha establecido para el ocultar información, dado que dicha información ha sido manejada y colocada en esta parte del archivo PostScript, es decir, el programa Extractor se encargará de leer la precisión predeterminada en el programa generador para obtener de ella la información oculta y con estos datos armar la información protegida nuevamente en el aspecto original del archivo protegido previamente especificado. Lo anterior tiene el siguiente flujo de funcionamiento: 44 Fig. 16. Flujo de Extracción En el flujo se tiene como premisa a cumplir dos parámetros, estos son el indicar el archivo PostScript que se tiene con información oculta y el nombre del archivo a escribir con dicha información recuperada, con esta información el programa Extractor se encargara de tomar los valores colocados en el Stegano Objeto y con ellos reconstruir la información. Al igual que el modulo del Generador este modulo se ha elaborado en C bajo el mismo sistema operativo y ambiente de desarrollo, implementado con la misma técnica de programación. En este modulo se encuentra la parte de recuperación de la información oculta en la lectura de métricas como se ha venido comentado, así que cabe decir que esta información puede ser vulnerada en algún momento del transporte del archivo PostScript, accediendo por medio de un editor y no por un visor de PostScript, pero también es importante conocer que la posibilidad de dañar dicha información oculta es poco probable dado que quien deseara modificar la información podría modificar mas probablemente alguna otra parte de la estructura PostScript ademas de la precisión de las métricas, es común por ejemplo desear modificar las cadenas de texto a mostrar en lugar de las posiciones bajo la precisión en las que se ha almacenado la información a ocultar, esto debido a que el archivo PostScript no es un elemento que despierte fácilmente un algo grado de sospecha para verse como candidato a ser un elemento de transporte de información oculta. La ventaja de que el archivo PostScript sea visto como un archivo mas, el cual contiene información “normal” de la que no se sospeche fácilmente, oferta la ventaja de poder ser descartado para un stego Análisis con mayor facilidad y continuar sus caminos hasta llegar al destinatario quien lo espera conjunto al programa Extractor, al cual le proporcionara dicho archivo como un primer parámetro y un nombre cualquiera como segundo parámetro para obtener la recuperación de la información, como se muestra a continuación: 45 Fig. 17. Utilización en línea de comando para el programa Extractor Uso Ciclo Ocultamiento – Recuperación Anteriormente se ha comentado sobre los módulos principales que cumplen el proteger o ocultar información tanto como el recuperarla; a este procedimiento completo se le define como el ciclo de Ocultamiento – Recuperación. Ambos pasos deben tener criterios a cumplir para que cumplan sus cometidos. Los principales requisitos son los que requiere cada modulo sobre la línea de comando. En esta sección se describe como se pueden utilizar estos comandos, también definidos como los “módulos” para cumplir con este ciclo. El primero de ellos es el comando “./DirTxt2PS” secundado por el comando “./PS2TXT”. Ambos trabajan sobre el mismo sistema operativo donde han sido desarrollados y según la estructura del sistema de archivos del Sistema Operativo gestor donde han sido compilados. En ambos módulos se deben especificar parámetros para que estos ejecuten su labor. En relación a la forma de trabajo para el sistema de archivos, se refiere a la manera de indicar una ruta de un directorio o de un archivo sobre el sistema de archivos. Parámetros para el Ocultamiento En el modulo para ocultar o proteger información se requiere de dos parámetros principales, estos indican la ruta del archivo o directorio de o los archivos de texto portadores y el archivo de texto plano a ocultar dentro del archivo o archivos portadores respectivamente. Estos parámetros son separados por un espacio y pueden o no ser especificados con ayuda de comillas, por ejemplo: ./DirTxt2PS "Portador.txt" "Secreto.txt" ó ./DirTxt2PS Portador.txt Secreto.txt 46 Además se requiere opcionalmente de conocer para la generación del PostScript final los parámetros de formato, estos son: • • • • • Ancho de la Hoja Alto de la Hoja Espacio entre líneas Margen Izquierdo Margen Derecho • • • • • Margen Superior Margen Inferior Letras por Línea Mayúsculas por Línea Tamaño de Letra La siguiente imagen muestra la apariencia que tiene la toma de valores para los parámetros de formato: Fig. 18. Definición de Parámetros de formato en ejecución del programa generador Los parámetros anteriormente comentados son los requeridos por el programa generador para armar el resultado final en el PostScript que ocultara determinada información. Es importante comentar que en la ausencia de alguno de los parámetros principales, se tienen los casos siguientes. 47 • • Que no se encuentre el directorio o el archivo especificado para tener como portador o portadores. Que no se encuentre el archivo especificado a ocultar en los o el portador. Los casos dichos pueden ocurrir al mismo tiempo, sin embargo cabe señalar que en el segundo caso al no encontrarse el archivo a ocultar si se ha encontrado el primer parámetro como valido se generara un archivo PostScript con los formatos definidos o no pero sin información que viaje oculta. Parámetros y uso de Portadores Específicamente el parámetro contemplado para tomar como portador o portadores, puede ser un archivo o un directorio, de donde se tomaran todos los archivos de tipo texto plano para procesar como archivos portadores del segundo parámetro que especifica la información a ocultar. En el momento de especificar un directorio, el programa selecciona solo los archivos de texto y los convierte en archivos PS con o sin información oculta, según sea el caso, como se muestra a continuación. Ejecutaremos el comando: “./DirTxt2PS DirAbel Secreto.txt” Sobre la siguiente estructura en el sistema de archivos: Fig. 19. Estructura de ficheros ejemplo en Sistema de Archivos Donde se aprecian 6 archivos de texto plano y un archivo de texto enriquecido. Es importante saber que el segundo parámetro considera parte de su ruta al primer parámetro así el archivo “Secreto.txt” será buscado en el directorio que se especifica en el primer parámetro y no como archivo existente a lado del programa generador. 48 El contenido de cada archivo es muy variado y en la siguiente imagen solo se visualiza una pequeña muestra del contenido de los archivos: Fig. 20. Ejemplo de contenido en archivos de Texto En el comando especificamos el archivo de nombre “Secreto.txt” como archivo a ocultar, para lo que el programa generador tomara los archivos de texto plano excepto el de texto enriquecido “RecuperarText.rtf”, y con ello no excluirá el archivo “Secreto.txt” para trabajar en ocultar información con PostScript, teniendo un resultado lo siguiente: Fig. 21. Nombres de archivos PS generados 49 Cabe mencionar que a pesar de considerar el archivo “Vacio.txt” este no posee información, y siendo así este no será procesado, por tanto no se genera un archivo PostScript vacío y por ende resultarán 5 archivos de los 6 archivos de texto claro localizados. Los archivos anteriores tienen el siguiente aspecto (Lado izquierdo de la imagen) bajo los parámetros de formato considerados por omisión. Fig. 22. Comparativa ente texto plano y texto en PostScript Cada uno de estos archivos contiene oculta la información del archivo “Ocultar.txt”. Es importante señalar que para el caso de que se detecte que el archivo a ocultar no puede estar completamente oculto en alguno de los archivos portadores de la información a ocultar, se hace un anuncio del caso y se prosigue con proteger la información que logre completarse de forma oculta en el archivo resultante. Existe un caso particular que es importante considerar, este es donde se oculta cierta información igual, es decir por ejemplo, ocultar el nombre “Abel” en otra palabra “Hola”, solo se podrán ocultar las letras “Abe”, pues debido a las características de la técnica de Esteganografía que se usa, se tiene una capacidad total de proteger el texto requerido en otro texto; de el mismo número de letras menos un carácter por renglón, esto es una gran ventaja debido a que en otros programas se puede requerir hasta mas de tres veces la cantidad de texto para lograr ocultar determinado texto y necesitando para estos programas mas de una palabra o cadenas de texto que la palabra o información a ocultar. 50 Parámetros y uso de Extracción Los parámetros utilizados en el proceso de Extracción, al igual que los parámetros del proceso de Ocultación, se utilizan sobre la línea de comando. Estos son dos y se refieren a el archivo fuente que contiene la información oculta y el segundo al nombre del archivo que deseamos tenga la información que se extraiga, este puede ser cualquiera y podemos especificar opcionalmente un extensión de archivo de texto plano, generalmente TXT. Ambos parámetros deben separarse por un espacio y estos deben estar en el directorio del proceso de Extracción. En esta demostración usaremos una estructura como se muestra a continuación para probar el procedimiento de extracción. Fig. 23. Archivos de prueba para Extracción 51 Ejemplo del comando: “./PS2TXT EstudioArte.txt.ps RecuEstudioArte.txt” Fig. 24. Apariencia de una recuperación de Información 52 En la recuperación anterior vemos el resultado de una manera completa y exitosa, esta consiste de que el portador especificado haya sido un contenedor suficiente para poder haber colocado la información que ahora vemos como recuperada. Anteriormente se comento acerca de la capacidad de almacenar información dentro de los archivos portadores y se estableció una referencia de la cantidad de información total para lograr transportar un texto, esta debe ser mayor en un carácter que la cantidad de caracteres a ocultar por renglón, es decir, se requiere la misma cantidad de caracteres mas un carácter en el renglón de el portador que la cantidad de caracteres que se tenga en el archivo a ocultar, esto para lograr transportar todos los caracteres del archivo a ocultar de lo contrario se ocultara hasta donde sea posible, por ejemplo si se tienen exactamente los mismos caracteres, no se podrán ocultar los últimos caracteres según el número de renglones que se tengan. Este efecto puede apreciarse en el caso de ocultar el archivo “Secreto.txt” en el mismo y tener como resultado el archivo “Secreto.txt.ps” para posteriormente extraer su información que terminaría siendo lo mismo que el archivo contiene originalmente. Lo comentado puede apreciarse en el siguiente ejemplo: + Portador + = Texto a Ocultar Fig. 25. = Archivo PS con Información Oculta Ejemplo de Ocultación entre el mismo texto Se toma un Archivo de texto plano y en el se ocultara la misma información a manera de prueba para la capacidad de transporte para información oculta, para posteriormente extraerla y comprobar la cantidad de información que se transporta oculta. 53 Generado el archivo PostScript y una vez con la apariencia del archivo portador igual a la del archivo de texto plano, pero con información oculta, cuando esta es la misma, el procedimiento de extracción no cambia, aemas el resultado es el esperado en relación a la capacidad de transporte para proteger información. Fig. 26. Extracción de un archivo oculto en si mismo Podemos apreciar como los últimos caracteres, incluyendo los espacios del archivo que se han ocultado anteriormente hacen falta sobre la recuperación de información oculta cuando hablamos de la misma cantidad de texto a ocultar como para portar. En este ejemplo faltan 25 caracteres a partir del final del archivo, estos caracteres son en relación a los 25 renglones que se tienen del archivo. 54 CAPITULO 5 La elaboración de pruebas que logren medir aceptaciones sobre una propuesta, es un resultado que nos permite evaluar determinada aceptación de un evento, acción o objeto. Dicha prueba para calcular un nivel de aceptación acerca de lo que se propone, en el caso de la propuesta de que impresos son idénticos a pesar de que uno contiene diferencias, será un valor de aceptabilidad social frente a textos impresos en pantalla del formato PostScript o impresos en papel, donde el lector no logre encontrar diferencia alguna al momento de comparar visualmente estos documentos impresos; aún cuando su forma interna en su sintaxis informática son diferentes. Esta prueba es denomina prueba MOS y se encarga de medir esta aceptabilidad y la capacidad de adaptación los medios visuales del usuario, que en este caso será la capacidad de poder identificar como “idénticos” o no los archivos visualizados o impresos. PRUEBA MOS Como parte del resultado obtenido en la prueba MOS y búsqueda de la medida de efectividad a la hora de ocultar información y presentarla frente a los lectores se ha designado un conjunto de archivos prueba para generar y presentar a fin de localizar diferencias para calcular un factor de aceptabilidad. A continuación se describen las operaciones de la prueba MOS. Elaboración Se consideran archivos de texto de cantidad considerable en caracteres, hasta aproximadamente 6500 caracteres, en promedio de 20 hojas, para poder generar el archivo PS con información. A estos archivos se les proporcionará información a ocultar (Otro archivo de texto) y se harán impresiones con estos resultados, una impresión llevara información oculta y otra no portara alguna información. A las impresiones obtenidas con el generador del archivo PS, se les elabora un formulario de presentación para que en la participación de personas que tomen los documentos impresos, seleccionen las diferencias entre uno y otro texto. 55 PUEBA DE DIFERENCIAS VISIBLES EN COMPARACION El formato que se ha publicado para la participación de lectores es el siguiente: ___________________________________________________________________________________________________ La prueba consiste en evaluar dos textos impresos, uno de ellos contiene información oculta, para lo cual esta evaluación nos ayudara en base a una muestra estadística a valorar la eficacia del ocultamiento y el nivel de diferencias observadas texto vs. texto. Nivel de diferencias: Texto 1 Texto 2 Texto 3 Sin ninguna diferencia Una diferencia Diferencias muy especificas Muy similares Completamente Diferente Ing. Cano Jiménez Abel Nota: Los textos que se evalúan son impresos en un dispositivo láser de impresión normal y no deben presentar alteraciones físicas en el papel o diferentes tintas o marcas. Sexo: M ó F , Edad: _______ Años ___________________________________________________________________________________________________ Fig. 27. Formato para evaluación MOS de Impresiones PS Se han generado tres tipos de archivos, uno es un texto de gran longitud, y los otros dos son textos de memorando con formato respectivos al documento. El motivo de generar tres documentos es incrementar la posibilidad de tener algún detalle de visualización ademas de presentar diferentes tipos de documentos al lector. En cuanto a que son dos documentos relativamente pequeños se tiene para que las comparaciones sean mayormente analizadas y no pasadas en la mayoría de sus detalles por alto. El Formulario, se elabora de tal forma que permite especificar rápidamente y muy claramente las características que se buscan evaluar, en este estudio, los niveles de diferencia que puedan localizar los lectores para cada uno de los textos proporcionados. 56 Así entonces se elaboran 100 pruebas con los textos dichos. Estos archivos impresos en el PostScript tienen la siguiente apariencia. Fig. 28. Primer Memorando (Texto 1) Fig. 29. Segundo Memorando (Texto 2) 57 Fig. 30. Parte de Texto Largo en PostScript (Texto 3) Al momento de aplicar la prueba a cada una de las personas se les comenta acerca de que las lecturas que tienen en sus manos, tienen impresos textos comunes, y entre estos existen los mismos caracteres en tamaño, forma y formato, sin embargo poseen diferencias dado que uno de estos documentos posee información oculta y otro no, siendo así entonces la idea el encontrar alguna diferencia con cualquier método que se les ocurra para localizarla, puede ser medir, contraluz, etc. Las maneras en las que las personas han buscado diferencia entre los documentos han sido varias, desde leer por completo los documentos a fin de asegurar que no tienen algún carácter o inclusive palabra diferente entre una cantidad de palabras considerable como si tienen algún carácter de tamaño diferente o marcado a fin de armar una cadena posteriormente. Algunas otras personas optaron por comparar a contra luz la coincidencia de los caracteres buscando diferencias entre los cuadres de los margenes y párrafos de los textos; otros mas han seleccionaron medir con regla las distancias posibles a medir con este instrumento y buscar en posiciones que consideraron claves alguna diferencia. 58 RESULTADOS De las 100 pruebas aplicadas consistentes en evaluar tres textos, todas ellas a excepción de un texto fueron seleccionados conforme lo esperado en el cuestionario, marcándose como completamente idénticas y sin alguna diferencia, es decir que se consideraron los textos como iguales en todos los sentidos, a pesar de haberse comentado que tenían diferencias entre ellos. Cada uno de los cuestionarios se completo de manera satisfactoria según lo esperado, marcado como meta en el desarrollo de este trabajo, es decir, se ha conseguido en casi todas las pruebas que el usuario no dudara en decir que los textos; tanto el texto con información oculta como el texto sin esta información son completamente iguales. En cuanto al único texto seleccionado como diferente, la “diferencia” que supuso localizar la persona, ha sido el Texto 1 (El primer Memorando) y marcado como con una diferencia en un acento, esto a juzgar por una mujer de 21 años. Aunque cabe señalar que la posición de los acentos no es manipulada en ningún momento por parte del generador o extractor pues es considerado como parte del cuerpo del carácter y tiene sus métricas definidas para la forma de la letra, característica que no es tocada en ningún momento del procedimiento esteganografico. Considerando un porcentaje de 100 % el haber contestado por completo en todos los casos de cuestionario que no se ha detectado alguna diferencia en alguno de los textos presentados; y como una persona en un texto ha detectado una “modificación” en un acento, se ha marcado con una diferencia en un cuestionario, quedando un porcentaje de aceptación muy cercano a 100%, este porcentaje es el 99.66 %, considerando 300 puntos para un porcentaje completo de respuestas sin notar alguna diferencia, dado que cada encuestado verifico 3 impresiones, quedando el porcentaje final dicho por ser 299 puntos obtenidos en el cuestionario. Con base en los resultados visuales que se han obtenido, con los fundamentados en las encuestas y lo que se establece para la protección que se oferta con este método, se puede decir que es en pleno aceptable el formato electrónico e impreso en el cuanto al ocultamiento y sospecha nula de transporte de información se refiere. Es decir que no levanta sospecha alguna la técnica de esteganografía que se aplica para ocultar información. Tal es el resultado esperado que se ha obtenido que por el que se puede decir que se cumple con el objetivo de elaborar un formato en base a instrucciones PostScript que se a capaz de ocultar y/o proteger información de textos planos por medio de otros archivos del mismo tipo presentando una lectura exactamente igual al archivo que se utiliza como transporte, en este caso utilizando el PosScript, todo para la posterior recuperación de información con el programa de recuperación conforme se ha visto en el ciclo de ocultamiento y recuperación de la información. 59 Es importante señalar que tanto la recuperación del archivo debe ser igual en su lectura como en la estructura interna de archivo recuperado contra el original ocultado, es decir a nivel binario la forma del archivo exceptuando el nombre, dado que este puede llegar a ser dife rente, son completamente idénticos. Para demostrar esto se elaboro con ayuda de un programa de comparación binaria una búsqueda de diferencias para tratar de localizar estas diferencias entre estos archivos y este programa analiza y compara bit a bit dichos archivos. El resultado de la comparación bit a bit que nos resulta es satisfactoria, pues los archivos son señalados como completamente idénticos. Fig. 31. Comparación Binaria El resultado idéntico a nivel binario nos dice que el procedimiento de recuperación es correcto y el ensamble del archivo de texto en este procedimiento de recuperación es completado con éxito desde el inicio del archivo hasta su final, aunque esto es debido a que el programa de recuperación le encarga este trabajo al sistema de archivos del sistema operativo y por tanto la estructura del archivo no se ve comprometida a excepción de la información que se plasme en el archivo, que es directamente la que depende del algoritmo de recuperación. 60 APLICACIONES Y USOS Actualmente existen muchos programas de Esteganografía, la mayoría de ellos trabaja sobre grandes cantidades de información, pocos y con requerimientos muy particulares trabajan para los textos. Partiendo de la finalidad de la Esteganografía, sus usos y aplicaciones principales, donde encontramos el pasar determinada información por desapercibida al momento de buscar objetos sospechosos de transporte ocultos en una búsqueda, tanto como el posesionar información o marcar información como la marca de agua nos permite, son validas muchas técnicas de Esteganografía y con forme los resultados esta técnica es valida y aplicable para los fines propuestos. El uso de la Esteganografía varia según la cantidad de información y conforme las capacidades ofertadas por la creación de cada persona que la realiza. En el caso de requerir transportar gran información en forma de texto plano las ofertas comerciales y no comerciales que se encuentran actualmente, se enfocan en utilizar medios informáticos voluminosos como fotografías, sonidos, videos, pero cuando lo que se requiere transportar es poco volumen informático y gran valor de información como puede proporcionar una oración o un párrafo completo de texto, el utilizar un objeto grande para este objetivo no es algo muy eficaz o rápido, por lo que se ha propuesto este trabajo con estos resultados bastante aceptables y con una gran velocidad para lograr transportar cantidades grandes de texto con una relativa cantidad de texto igual en el archivo portador. Como se hace mención acerca de lo que importa proteger y/o ocultar determinada información que brinden los textos, también es importante conseguir una rápida transmisión de estos datos y esto no se consigue con volumenes altos de información sino con tipos de archivos que sean livianos en tamaño para poderlos transportar rápidamente y siendo esto una característica implícita aunque no obligada de los archivos PostScript, el ocultar información en ellos nos brinda una velocidad de trabajo para con estos archivos muy conveniente para transmitir gran cantidad de información en textos por cualquier medio de almacenamiento o transporte de red de gran capacidad actualmente. Combinada la posibilidad de transportar gran cantidad de información valiosa con archivos que tienen la opción a ser rápidamente accesibles por prácticamente cualquier dispositivo de impresión en pantalla, como las computadoras, el manejo de esta protección a la información puede generar el aplicarse a la compartición, protección, transporte de secretos de muy variados tipos, desde militares, gubernamentales o hasta personales. 61 Ademas de las aplicaciones que puedan encontrarse, es importante conocer el procedimiento que realiza en código fuente de la aplicación para no tener la duda de los rastreos que puedan estar aplicando las aplicaciones comerciales o no pero sin acceso al código fuente sobre la información que se oculte, pueden haber puertas traseras o alguna característica que permita a otros ademas de los deseados conocer la información oculta. La forma en la que se esta presentando el procedimiento de ocultación de la información, no es el único que utiliza características del texto para poder ocultar información, sin embargo utilizando las estructuras PostScript que brindan las sintaxis del lenguaje nos permiten poder presentar información en pantalla de manera muy ágil y sin sospechas de que esta información en pantalla que lee el usuario contiene información oculta. Esto permitiría que si alguna persona o entidad esta buscando comunicados por ejemplo que puedan tener frases sospechosas o estén comunicando alguna información en claves, sean detectados. Es decir que con esta metodología es posible presentar cualquier tipo de información que pueda parecer normal y muy natural con información oculta sin ser visible de ninguna manera en pantalla o impresión, situación que previamente ha sido comprobada con la prueba MOS. 62 CAPITULO 6 Modificaciones Futuras Una de las situaciones que comúnmente se presentan al final de los proyectos conforme al tiempo de desarrollo para los proyectos es poder incrementar características y funcionalidades que estén sobre la línea de trabajo en las investigaciones que se elaboren. En este trabajo al cumplirse los objetivos se pueden pensar determinadas mejoras y/o extensiones que pueden aplicarse. Una de estas implementaciones y talvez la mas importante es el poder transformar el archivo PostScript a un formato PDF debido a la popularidad que oferta este ultimo basado en PostScript, otra puede ser mediante la criptografía colocar el texto a ocultar en el estegano objeto ya cifrado, para conseguir aún mas complejidad para la extracción de la información auque se tenga como primer forma de la protección el no sospechar del transporte y/o protección de la información oculta mediante la Esteganografía ademas de la Criptografía. Otra posibilidad es disminuir el tamaño del archivo resultante mediante la reducción de precisiones en las posiciones que se marcan en cada letra para las líneas de los párrafos en el PostScript sin embargo esto debe estudiarse, pues podrían presentarse cambios visibles en el archivo resultante final. Una muy amplia extensión de la aplicación de archivos PostScript como medios portadores para ocultar y/o proteger información con la esteganografía, es poder hacerlos portar ademas de texto algún otro medio informático, es decir, ademas de archivos de texto plano, lograr colocar archivos de imágenes, sonidos, videos o hasta algún otro archivo como por ejemplo un ejecutable y este lograr ensamblarlo nuevamente. POSIBLES MEJORAS Al hablar de una expansión en este trabajo, podemos contemplar aspectos que en el desarrollo del trabajo se han contemplado y no se han implementado por la delimitación del tema de la investigación. Algunos de ellos se enlistan a continuación y quedan tentativos a implementar en un desarrollo que brinde continuidad. 63 Ampliar opciones de Formato Una de las características actuales en el programa son varios valores escalares para poder definir algunas características de la presentación y el aspecto visual final que resulta del proceso de ocultación de un texto sobre otro resultando en el archivo PostScript. Los valores4 para personalizar el formato que se han considerado en el programa de generación son solo algunos de los que se podrían solicitar en el proceso de creación del archivo portador, ademas de que se podrían especificar de alguna otra forma para poder acelerar o facilitar las presentaciones de los archivos que se estén generando, incluso podría ser ya algún archivo de configuración normalizado para que se tome por el proceso de generación y este sea reflejado en el resultado visual del archivo PostScript. Criptografía antes de Esteganografía La protección que se oferta en este desarrollo, esta basada en la Esteganografía, que como se ha comentado anteriormente brinda la oportunidad de pasar información por medio de otra a manera que una tercera entidad en el medio de la comunicación no sospeche de tal información. Así con tal característica, determinada información pueda protegerse. Adicionando la propiedad de cifrado a dicha información a proteger por medio de la Esteganografía, se puede tener un “disfraz” mas complejo para localizar información que se sospecha esta esteganografiada, esto haría pasar a la información a proteger como simple ruido o parte del medio portador. Esta característica puede implementarse antes o en conjunto al modulo de generación del PostScript, esto debería considerarse pues no se debe perder la finalidad y las propiedades del proyecto, como velocidad de generación, portabilidad, etc. Disminuir tamaño de archivos finales Una propiedad mas que se vuelve deseable pero hasta ahora no probada como estable y aprobada visualmente, es el lograr disminuir aún mas el tamaño del archivo final en la cantidad de bytes, esto comparado con un archivo común PDF con o sin información esteganografiada. Es decir lograr hacer mas liviano el archivo final que portara la información oculta. Esto tiene un grado de complejidad para lograrlo dado que en base a la técnica de Esteganografía aplicada actualmente, se obtiene un tamaño 64 proporcional en el archivo resultante final y este no varia notablemente de un archivo PostScript que contenga información y de otro que no la posea, sin embargo esta forma de aplicar dicha Esteganografía es directamente relacionada a la minima posibilidad de que un observador pueda visualizar alguna diferencia. El adquirir esta ventaja implicaría modificar en alguna medida la técnica esteganografica, lo que acarrea, elaborar nuevas pruebas y generaciones de archivos PostScript posiblemente diferentes en sus estructuras sintácticas. Incluir archivos multimedia El lograr ocultar información o datos en texto dentro de otro texto es una gran ventaja, sobre todo contra la mayoría de los programas dedicados a la Esteganografía, sin embargo no es siempre la necesidad el ocultar este tipo de información en los textos. Así entonces la prestación que se genera con este proyecto puede mejorar si una técnica como la propuesta se le adiciona la capacidad de portar otro tipo de documentos, donde estos pueden ser desde archivos de capacidades multimedia hasta archivos binarios o ejecutables que puedan ser útiles en diferentes sistemas operativos pues el archivo portador puede tener la finalidad de ser utilizado en algún otro sistema operativo para extraer información o archivos útiles para el destino o destinatario. Para el caso de los archivos multimedia, estos han tenido mayor desarrollo en el campo comercial y libre para la Esteganografía, así que es importante considerarlos en un futuro para poder ensamblar una imagen, un sonido o inclusive algún tipo de video a partir de un archivo PostScript, o considerar el tener varios archivos PostScript para completar determinada capacidad de transporte, debido a que la cantidad de datos que arman un archivo de los medios comentados requiere mayor cantidad de bytes, lo que nos obliga a tener dicha cantidad en un archivo PostScript, auque ademas puede considerarse la posibilidad de tener mas de un archivo PostScript para completar el transporte. Incluir archivos binarios o ejecutables Para el caso de los archivos binarios o ejecutables, tal como es el caso de los archivos multimedia, presentan el la mayoría de los casos un tamaño considerable de bytes que se tienen para armar dicho archivo, sin embargo no siempre es así y se pueden tener archivos muy livianos con grandes capacidades de ejecución y labores en un sistema operativo. Tal es el caso, similar en tamaño en archivos ejecutables, pero aquí la diferencia que marca la posible mejora es el reensamblar la estructura interna del archivo binario o ejecutable para que sea un archivo valido en otro sistema operativo. 65 Compilación en otros Sistemas Operativos Este proyecto ha sido desarrollado en el sistema operativo MAC OS X y se compilo en el administrador de proyectos X Code con un compilador GCC sobre el lenguaje de C; lo que proporciona a este desarrollo tener una gran portabilidad hacia otras plataformas pues no se hace uso de librerías dependientes del sistema operativo. Lo anterior permite al momento de llevar el desarrollo a una plataforma diferente , en relación al sistema operativo, se puede lograr una compilación sin mayores dificultades, sin embargo este cambio entre sistemas operativos debe estudiarse pues las codificaciones de los archivos de texto suelen ser utilizadas en formas diferentes, y esto puede cambiar el funcionamiento o la apariencia que se tratan en el programa generador. El caso mas probable es llevar el proyecto a un sistema operativo Windows, para lo cual se tendrían que compilar y generar los archivos “.exe” propios del sistema operativo para ejecución de programas. Actualmente existe un ambiente de desarrollo que utiliza una versión reciente del compilador “gcc” sobre Windows, este proyecto tiene el nombre de “Dev C++”. 66 CAPITULO 7 CONCLUSIONES El trabajo actual es uno de varios posibles procedimientos esteganograficos utilizando texto como portador de información oculta, sin embargo este trabajo aporta un avance sobre la forma de utilizar estos textos para ocultar otros textos; en el caso aprovecha a el lenguaje de PostScript, que nos permite con cierta facilidad posicionar caracteres, puntos y vectores en cualquier parte de un área previamente definida, característica que se aprovecha para poder aplicar Esteganografía y aprovechar las precisiones imperceptibles de los caracteres que se pueden especificar y posteriormente leer para obtener la información que ha sido oculta en estas características. Finalmente en base al objetivo de la Esteganografia, el trabajo presentado en este desarrollo alcanza sus objetivos, el utilizar la Esteganografía para generar un documento electrónico PostScript y manejar archivos de texto claro como portadores de otros textos planos electrónicos, tanto como lograr hacer pasar a estos archivos sin mayor importancia de la que se lee en su contenido y por desapercibido el hecho de que transportan información oculta para finalmente extraer dicha información que siempre se ha considerado otro archivo de texto plano y escribirlo en el sistema de archivos en su forma original, perdiendo únicamente su nombre inicial y no su contenido. Se tiene así con la combinación del formato electrónico y la Esteganografía un resultado optimo para poder transportar y ocultar gran cantidad de información obtenida de archivos de texto plano en archivos que presentan otro texto pero en el formato ya comentado; situación que ha sido prevista desde el inicio del desarrollo. 67 BIBLIOGRAFIA • • • • • • • A New Synonym Text Steganography. M. Hassan Shirali‐Shahreza, Computer Engineering Department, Yazd University, Yazd, IRAN, hshirali@yazduni.ac.ir Mohammad Shirali‐Shahreza, Computer Science Department, Sharif University of Technology, Tehran, IRAN, irali@cs.sharif.edu Steganography in MMS. Mohammad Shirali‐Shahreza, Computer Science Department, Sharif University of Technology, Tehran, IRAN, shirali@cs.sharif.edu An Evolution of Hindi Text Steganography Kalavathi.Alla, Christu Jayanthi Jubilee College, Kalavathi_alla@yahoo.com Dr. R. Siva Rama Prasad, Acharya Nagarjuna University, raminenisivaram@yahoo.co.in A First Guide to PostScript Peter Weingartner, 24 February, 2006, http://www.tailrecursive.org/postscript/postscript.html Imagen Digital. Qué es el lenguaje PostScript, 2003, http://www.gusgsm.com/que_es_el_lenguaje_postscript PostScript Salvador Ramirez Flandes (sram), 2000, http://bosque.udec.cl/~sram/manuals/ps.pdf Adobe PostScript 3 Copyright © 2010 Adobe Systems Incorporated, http://www.adobe.com/products/postscript 68 • • • • • • Linux Focus. El Lenguaje PostScript, © 1998 Emre Demiralp, Traducido por Hugo Lastras Membrive y César Ordiéana. http://es.tldp.org/LinuxFocus/pub/mirror/LinuxFocus/Castellano/May1998/ article43.html Introducción al lenguaje C © 1994‐2008 Universidad de Las Palmas de Gran Canaria, José Miguel Santos Espino http://sopa.dis.ulpgc.es/so/cpp/intro_c/ Como programar en C/C++ H.M. Deitel, / P.J. Deitel, Prentice Hall, 1994, 2da. Edición. Unix programación avanzada Francisco Manuel García Addison Wesley Iberoamericana, 1994 1a. Edición. Tutorial Lenguaje C Area de Servicios, Departamento de Informábamostica, Universidad Nacional de San Luis http://www.dirinfo.unsl.edu.ar/~cur_servicios/fundamentos/manualC2007.p df Mean Opinion Score (MOS) ‐ A Measure Of Voice Quality. Nadeem Unuth http://voip.about.com/od/voipbasics/a/MOS.htm 69 ANEXO 1 Código Fuente del Generador #include <iostream> #include <fstream> #include <dirent.h> #include <stdio.h> #include <string> #include <stdlib.h> #include <math.h> #include <sys/stat.h> #include <time.h> /* Incluimos librerias propietarias ( definiciones y metricas ) */ #include "definiciones.h" #include "TimesNew.h" unsigned int AnchoHoja = PageWidthLetter; unsigned int AltoHoja = PageHeighLetter; unsigned int EspacioLinea = DefaultRowSpacing; unsigned int MargenIzq = DefaultLeftMargin; unsigned int MargenDer = DefaultRightMargin; unsigned int MargenSuperior = DefaultTopMargin; unsigned int MargenInferior = DefaultButtonMargin; unsigned int LetrasPorLinea = DefaultRowWrap; unsigned int MayusPorLinea = DefaultMAYUSCTES; unsigned int TamanyoLetra = DefaultFontSize; unsigned int DefParametros = 0; char *TipoDeLetra = FuenteDefault; void txt2ps(char *iDirect, char *ArtchivoTXT, char *ArtchivoPS, char *ArtchivoSECR) /* Rutina principal */ { /* Definiciones de proceso*/ FILE *PtrIn, *PtrOut, *PtrExt; /* Apuntadores al los archivos*/ char *FileIn, *FileOut, *FileExt, *CharFinal; //, *ElDirectorioX; struct stat file; char *Buffer, *BufferExt, *Row, *RowLatin, *RowExt, Number[10], CharAcounte, unsigned long int i,j,N,N_Ext,E,PtrBufferExt,LongArchivo,LongArchivoExt,Npage,MayusReng; int PtrBuffer, PrintingWidth, RightMargin, LeftMargin, PrintingHeigh, TopMargin, ButtonMargin, RowSpacing, Ajuste, Wrap, L, L_Ext, ValOcu, Aux; float Xpos,Ypos,Sum,Dx,AuxF,FontSize,RowsPerPage,*Metrics; time_t current_time; /* Interpretacion de parametros de la linea de comandos */ FileIn = (char *) calloc(strlen(iDirect)+1+strlen(ArtchivoTXT), sizeof(char )); FileOut = (char *) calloc(strlen(iDirect)+1+strlen(ArtchivoPS)+3,sizeof(char )); FileExt = (char *) calloc(strlen(iDirect)+1+strlen(ArtchivoSECR),sizeof(char )); for(i=0;i<=strlen(iDirect);i++) { FileIn[i] = iDirect[i]; FileOut[i] = iDirect[i]; FileExt[i] = iDirect[i]; } i‐‐; FileIn[i] = '/'; FileOut[i] = '/'; FileExt[i] = '/'; i++; j=i++; SN; 70 if(strlen(iDirect) == 1) { j = 2; i = 2; FileIn[1] = '\0'; FileOut[1] = '\0'; FileExt[1] = '\0'; N = 2; } else N = 3; if(strlen(iDirect) == 0) { i = 1; N = 1; } for(j=i;j‐i<=strlen(iDirect)+strlen(ArtchivoTXT)‐N;j++) // Ajustar el 4 a variable segun la condicion { FileIn[j‐1] = ArtchivoTXT[j‐i]; FileOut[j‐1] = ArtchivoPS[j‐i]; } for(j=i;j‐i<=strlen(iDirect)+strlen(ArtchivoSECR)‐N;j++) { FileExt[j‐1] = ArtchivoSECR[j‐i]; } FileOut = strcat(FileOut,".ps"); if(!DefParametros) { do { fprintf(stdout,"\n¿Definir Nuevos Valores a Parametros de Formato? s/n "); scanf("%c",&SN); }while (SN != 's' && SN != 'n' && SN != 'S' && SN != 'N'); if(SN == 's' || SN == 'S') { do{fprintf(stdout,"\n Ancho de la Hoja %i [Entero +]: ",AnchoHoja); scanf("%i",&AnchoHoja); } while (AnchoHoja <= 0); do{fprintf(stdout,"\n Alto de la Hoja %i [Entero +]: ",AltoHoja); scanf("%i",&AltoHoja); } while (AltoHoja <= 0); do{fprintf(stdout,"\nEspacio entre lineas %i [Entero +]: ",EspacioLinea); scanf("%i",&EspacioLinea); } while (EspacioLinea <= 0); do{fprintf(stdout,"\n Margen Izquierdo %i [Entero +]: ",MargenIzq); scanf("%i",&MargenIzq); } while (MargenIzq <= 0); do{fprintf(stdout,"\n Margen Derecho %i [Entero +]: ",MargenDer); scanf("%i",&MargenDer); } while (MargenDer <= 0); do{fprintf(stdout,"\n Margen Superior %i [Entero +]: ",MargenSuperior); scanf("%i",&MargenSuperior); }while (MargenSuperior <= 0); do{fprintf(stdout,"\n Margen Inferior %i [Entero +]: ",MargenInferior); scanf("%i",&MargenInferior); }while (MargenInferior <= 0); do{fprintf(stdout,"\n Letras por Linea %i [Entero +]: ",LetrasPorLinea); scanf("%i",&LetrasPorLinea); }while (LetrasPorLinea <= 0); do{fprintf(stdout,"\nMayusculas por Linea %i [Entero +]: ",MayusPorLinea); scanf("%i",&MayusPorLinea); } while (MayusPorLinea <= 0); do{fprintf(stdout,"\n Tamanyo de Letra %i [Entero +]: ",TamanyoLetra); scanf("%i",&TamanyoLetra); } while (TamanyoLetra <= 0); fprintf(stdout,"\n Ancho de la Hoja %i",AnchoHoja); fprintf(stdout,"\n Alto de la Hoja %i",AltoHoja); fprintf(stdout,"\nEspacio entre lineas %i",EspacioLinea); fprintf(stdout,"\n Margen Izquierdo %i",MargenIzq); fprintf(stdout,"\n Margen Derecho %i",MargenDer); fprintf(stdout,"\n Margen Superior %i",MargenSuperior); fprintf(stdout,"\n Margen Inferior %i",MargenInferior); fprintf(stdout,"\n Letras por Linea %i",LetrasPorLinea); fprintf(stdout,"\nMayusculas por Linea %i",MayusPorLinea); fprintf(stdout,"\n Tamanyo de Letra %i",TamanyoLetra); } } //{ /* Comercial */ fprintf(stdout,"\nCopyright(c) 2010 por Mario Gonzalez Lee && Cano Jiménenez Abel.\nGrupo de Esteganalisis\nIPN ‐ ESIME CULHUACAN ‐ ESITI\n"); fprintf(stdout,"\nArchivo de entrada: %s\nArchivo de salida: %s\nArchivo a ocultar: %s\n",FileIn,FileOut,FileExt); if (!FileIn) { fprintf(stdout,"\nNo se ha especificado el archivo de texto portador..."); } 71 if (!FileOut) { fprintf(stdout,"\nNo se ha especificado el archivo destino en P.S. ..."); } if (!FileExt) { fprintf(stdout,"\nNo se ha especificado el archivo de texto que sera ocultado..."); } PtrIn=fopen(FileIn,"r"); // Abrimos al archivo para lectura... if (!PtrIn) /*Desplegamos mensaje de error y salimos de la aplicacion...*/ fprintf(stderr,"ERROR: El archivo %s no se encontro o no existe...\n",FileIn); else { /*Procesamos al archivo*/ stat(FileIn,&file); // verificamos el tamanio del archivo... LongArchivo = file.st_size; fprintf(stdout,"\nLongitud del Texto Portador: %i\n",LongArchivo); Buffer = (char *) calloc(LongArchivo,sizeof(char)); // reservamos memoria para el Buffer if(Buffer==NULL) { /* Si no se ha podido reservar memoria... */ fprintf(stderr,"ERROR: No se ha podido reservar memoria...\n"); //N=NULL; //Marca Warning en Windows N=0; } else N = fread(Buffer,sizeof(char),LongArchivo,PtrIn); /* Leemos los datos al Buffer */ if (!N) { /* Si no se han leido datos en el archivo... */ fprintf(stderr,"ERROR: El archivo %s no se puede leer o no contiene datos.\n",FileIn); free(Buffer); } else { //*********************************************************************************** PtrExt = fopen(FileExt,"r"); // Abrimos al archivo para lectura... if (!PtrExt) { /* desplegamos mensaje de error y salimos de la aplicacion...*/ fprintf(stderr,"ERROR: El archivo %s no se encontro o no existe...\n",FileExt); } else { /*Procesamos al archivo*/ stat(FileExt,&file); // verificamos el tamanio del archivo... LongArchivoExt = file.st_size; fprintf(stdout,"\nLongitud del Texto a Ocultar: %i\n",LongArchivoExt); BufferExt = (char *) calloc (LongArchivoExt+1,sizeof(char)); // reservamos memoria para el Buffer CharFinal = (char *) calloc(1,sizeof(char)); if(BufferExt == NULL || CharFinal == NULL) { /* Si no se ha podido reservar memoria... */ fprintf(stderr,"ERROR: No se ha podido reservar memoria...\n"); //N_Ext = NULL; //Marca Warning en Windows N_Ext = 0; } else { CharFinal = "#"; N_Ext = fread(BufferExt,sizeof(char),LongArchivoExt+1,PtrExt); /* Leemos los datos al Buffer */ } if (!N_Ext) { /* Si no se han leido datos en el archivo... */ fprintf(stderr,"ERROR: El archivo %s no se puede leer o no contiene datos.\n",FileExt); free(BufferExt); } else { fprintf(stdout,"\nListo el Bufeer Externo...\n"); } RowExt = (char *) calloc(LongArchivoExt+1,sizeof(char)); PtrBufferExt = 0; 72 //***************************************************************************************** //fprintf(stdout,"\nContenido del Archivo Externo:"); for(j=0;j<=LongArchivoExt;j++) // llenamos los caracteres del renglon RowExt[j‐PtrBufferExt] = BufferExt[j]; //***************************************************************************************** RowExt[j‐PtrBufferExt]='\0'; PtrBufferExt=j; /* Actualizamos el puntero.. */ L_Ext = strlen(RowExt); } //*********************************************************************************** if(LongArchivoExt > LongArchivo) fprintf(stdout,"\n La Cantidad de InformaciÛn a ocultar es Mayor a el Texto Original"); // Definiciones de parametros... PtrBuffer = ‐1; Wrap = LetrasPorLinea; LeftMargin = MargenIzq; RightMargin = MargenDer; TopMargin = MargenSuperior; ButtonMargin= MargenInferior; RowSpacing = EspacioLinea; FontSize = DefaultFontSize; Npage = 1; E = 0; ValOcu = 0; MayusReng = 0; // Calculo de parametros de trazo PrintingWidth = AnchoHoja‐RightMargin ‐ LeftMargin ; PrintingHeigh = AltoHoja ‐TopMargin ‐ ButtonMargin ; RowsPerPage = floor(PrintingHeigh/RowSpacing); Xpos = LeftMargin; Ypos = AltoHoja‐TopMargin; // Reservamos memoria... Row = (char *) calloc(Wrap+1,sizeof(char )); // reservamos memoria para renglon RowLatin= (char *) calloc(Wrap+1,sizeof(char )); // reservamos memoria para renglon Metrics = (float *) calloc(Wrap+1,sizeof(float)); // reservamos memoria para renglon //Comenzamos a escribir el archivo PostScript que contendra el archivo oculto current_time = time(NULL); PtrOut = fopen(FileOut,"w"); fprintf(stdout,"\n Escribiendo ."); // Imprimimos encabezado EPS fprintf(PtrOut,"%%!PS‐Adobe‐2.0\n%%%%Pages: \n%%%%Creator: Mario Gonzalez Lee\n"); fprintf(PtrOut,"%%%%Title: %s\n%%%%PageOrder: Ascend\n%%%%BoundingBox: 0 0 %d %d\n",FileIn,AnchoHoja,AltoHoja); fprintf(PtrOut,"%%%%CreationDate: %s%%%%BeginSetup\n%%%%PaperSize: Letter\n%%%%EndSetup\n\n",ctime(&current_time)); fprintf(PtrOut,"%% ISO encoding by Peter Vollenweider (F¸r unix/mail Sept 1993)\n"); fprintf(PtrOut,"/ReEncode {\n"); fprintf(PtrOut," exch findfont\n"); fprintf(PtrOut," dup length dict\n"); fprintf(PtrOut," begin\n"); fprintf(PtrOut," { 1 index /FID eq\n"); fprintf(PtrOut," { pop pop }\n"); fprintf(PtrOut," { def } ifelse\n"); fprintf(PtrOut," } forall\n"); fprintf(PtrOut," /Encoding ISOLatin1Encoding def\n"); fprintf(PtrOut," currentdict\n"); fprintf(PtrOut," end\n"); fprintf(PtrOut," definefont\n"); fprintf(PtrOut," pop\n"); fprintf(PtrOut,"} bind def\n"); fprintf(PtrOut,"%% recodificamos la fuente Times‐Roman en _Times‐Roman\n"); fprintf(PtrOut,"/Times‐Roman /_Times‐Roman ReEncode\n"); 73 fprintf(PtrOut,"/_Times‐Roman\tfindfont\n%f \tscalefont\tsetfont\n\n%%%%Page: %i %i\n",FontSize,Npage,Npage); fprintf(stdout,"."); do { /* Procesamos al archivo */ Ajuste = 0; PtrBuffer += 1; //{ Localizamos el incio y el fin del renglon..... MayusReng = 0; for(i=PtrBuffer;i<PtrBuffer+Wrap;i++) { if( ( int(Buffer[i]) >= 65 & int(Buffer[i]) <= 90 ) | int(Buffer[i]) == ‐124 ) MayusReng++; //Veo Puras Mayusculas en el renglon if((Buffer[i] == ENTER) | (Buffer[i] == LF) | (Buffer[i] == '\0') | MayusReng >= DefaultMAYUSCTES ) break; } if(PtrBuffer+Wrap < LongArchivo) { if( (Buffer[i] != ENTER) & (Buffer[i] != LF) & (Buffer[i] != '\0')) { for(;i>0;i‐‐) //Recorro atras hasta un espacio if(Buffer[i] == SPACE) break; } } else { if((Buffer[i] == ENTER) | (Buffer[i] == LF) | (Buffer[i] == '\0')) { Ajuste = 0; while((Buffer[i] == ENTER) | (Buffer[i] == LF)) { i++; Ajuste++;} //Ajuste recorre hacia atras el puntero a fin de cortar cuando hay un salto de carro o linea nueva, a veces solo hay uno } else i = LongArchivo; } for(j=PtrBuffer;j<i‐Ajuste;j++) // llenamos los caracteres del renglon { Row[j‐PtrBuffer] = Buffer[j]; } //Row[j‐PtrBuffer+0]=NULL; /* Terminamos al renglon... */ /*Marca Warning en Windows*/ Row[j‐PtrBuffer+0] = '\0'; PtrBuffer = j; /* Actualizamos el puntero.. */ L = strlen(Row); if(L>0) {//Si el renglon contiene mas de un caracter... //Determinamos la justificacion del texto Sum=0; for(i=0;i<L;i++) { Aux = (int) Row[i]; if (Aux <=0 ) { if (Aux == ‐121) { Aux = int('a'); } else if (Aux == ‐114) { Aux = int('e'); } else if (Aux == ‐110) { Aux = int('i'); } else if (Aux == ‐105) { Aux = int('o'); } else if (Aux == ‐100) { Aux = int('u'); } else if (Aux == ‐106) { Aux = int('n'); } else if (Aux == ‐124) { Aux = int('N'); } else if (Aux == ‐63) { Aux = int('i'); } //¡ else if (Aux == ‐76) { Aux = int('y'); } else if (Aux == ‐108) { Aux = int('i'); } //î else if (Aux == ‐13) { Aux = int('U'); } //Û else if (Aux == ‐64) { Aux = int('?'); } //¿ else if (Aux == ‐97) { Aux = int('u'); } //¿ else if (Aux == ‐96) { Aux = int('T'); } //† else if (Aux == ‐113) { Aux = int('e'); }//è else if (Aux == ‐14) { Aux = int('U'); }//Ú 74 else if (Aux == ‐22) { Aux = int('I'); }//Í else if (Aux == ‐125) { Aux = int('E'); }//É else if (Aux == ‐25) { Aux = int('A'); }//Á else if (Aux == ‐18) { Aux = int('O'); }//Ó else if (Aux == ‐107) { Aux = int('I'); } else if (Aux == ‐85) { Aux = int('i'); }//´ else if (Aux == ‐95) { Aux = int('i'); }//° else if (Aux == ‐56) { Aux = int('B'); }// >> else if (Aux == ‐43) { Aux = int('i'); }// ’ else if (Aux == ‐48) { Aux = int('‐'); }// ‐ else if (Aux == ‐91) { Aux = int('*'); }// * else if (Aux == ‐46 | Aux == ‐45) { Aux = int('"'); } else { Aux = (int) Row[i]; } } Sum += character[abs(Aux)]; } if ( (L‐1) <= 0 && int(Row[i]) <= 0 ) { if( L >.85*Wrap ) Dx=(AnchoHoja‐LeftMargin‐RightMargin‐Sum); else Dx = .3*Sum; } else { if( L >.85*Wrap ) Dx=(AnchoHoja‐LeftMargin‐RightMargin‐Sum)/(L‐1); else { if (MayusReng >= DefaultMAYUSCTES) Dx = .464*Sum/(L‐1); else Dx = .3*Sum/(L‐1); } } for(i=0;i<L;i++) // Justificamos texto... { Aux = (int) Row[i]; if (Aux <= 0) {if (Aux == ‐121) { AuxF = character[abs(int('a'))] + Dx; } else if (Aux == ‐114) { AuxF = character[abs(int('e'))] + Dx; } else if (Aux == ‐110) { AuxF = character[abs(int('i'))] + Dx; } else if (Aux == ‐105) { AuxF = character[abs(int('o'))] + Dx; } else if (Aux == ‐100) { AuxF = character[abs(int('u'))] + Dx; } else if (Aux == ‐106) { AuxF = character[abs(int('n'))] + Dx; } else if (Aux == ‐124) { AuxF = character[abs(int('N'))] + Dx; } else if (Aux == ‐63) { AuxF = character[abs(int('i'))] + Dx; } else if (Aux == ‐76) { AuxF = character[abs(int('y'))] + Dx; } else if (Aux == ‐108) { AuxF = character[abs(int('i'))] + Dx; } else if (Aux == ‐13) { AuxF = character[abs(int('U'))] + Dx; } else if (Aux == ‐64) { AuxF = character[abs(int('?'))] + Dx; } else if (Aux == ‐97) { AuxF = character[abs(int('u'))] + Dx; } else if (Aux == ‐96) { AuxF = character[abs(int('T'))] + Dx; } else if (Aux == ‐113) { AuxF = character[abs(int('e'))] + Dx; } else if (Aux == ‐14) { AuxF = character[abs(int('U'))] + Dx; } else if (Aux == ‐22) { AuxF = character[abs(int('I'))] + Dx; } else if (Aux == ‐125) { AuxF = character[abs(int('E'))] + Dx; } else if (Aux == ‐25) { AuxF = character[abs(int('A'))] + Dx; } else if (Aux == ‐18) { AuxF = character[abs(int('O'))] + Dx; } else if (Aux == ‐107) { AuxF = character[abs(int('I'))] + Dx; } else if (Aux == ‐85) { AuxF = character[abs(int('i'))] + Dx; } else if (Aux == ‐95) { AuxF = character[abs(int('i'))] + Dx; } else if (Aux == ‐56) { AuxF = character[abs(int('B'))] + Dx; } else if (Aux == ‐43) { AuxF = character[abs(int('i'))] + Dx; } else if (Aux == ‐48) { AuxF = character[abs(int('‐'))] + Dx; } else if (Aux == ‐91) { AuxF = character[abs(int('*'))] + Dx; } else if (Aux == ‐46 | Aux == ‐45) { AuxF = character[abs(int('"'))] + Dx; } else { AuxF = character[abs(Aux)] + Dx; } } 75 else { AuxF = character[abs(Aux)] + Dx; } Metrics[i] = AuxF; } //Introducir la marca de agua... //COLOCAR LA INSERCION DEL CODIGO NUMERICO QUE DESCRIBA EL ACARACTER ESPECIAL CON ACENTOS fprintf(PtrOut,"\n%f\t%f\tmoveto\n(",Xpos,Ypos); for(i=0;i<strlen(Row);i++) { CharAcounte = int(Row[i]); if(int(Row[i]) == ‐121) { fprintf(PtrOut,"\\341"); }//a else if (int(Row[i]) == ‐114) { fprintf(PtrOut,"\\351"); }//e else if (int(Row[i]) == ‐110) { fprintf(PtrOut,"\\355"); }//i else if (int(Row[i]) == ‐105) { fprintf(PtrOut,"\\363"); } //Capicua//o else if (int(Row[i]) == ‐100) { fprintf(PtrOut,"\\372"); }//u else if (int(Row[i]) == ‐106) { fprintf(PtrOut,"\\361"); }//Ò else if (int(Row[i]) == ‐25) { fprintf(PtrOut,"\\301"); }//¡ else if (int(Row[i]) ==‐125) { fprintf(PtrOut,"\\311"); }//… else if (int(Row[i]) ==‐22) { fprintf(PtrOut,"\\315"); }//Õ else if (int(Row[i]) ==‐18) { fprintf(PtrOut,"\\323"); }//” else if (int(Row[i]) ==‐14) { fprintf(PtrOut,"\\332"); }//⁄ else if (int(Row[i]) ==‐97) { fprintf(PtrOut,"\\374"); }//¸ else if (int(Row[i]) ==‐63) { fprintf(PtrOut,"\\241"); }//¡ else if (int(Row[i]) ==‐76) { fprintf(PtrOut,"\\245"); }//Y else if (int(Row[i]) ==‐108) { fprintf(PtrOut,"\\356"); }//î else if (int(Row[i]) ==‐13) { fprintf(PtrOut,"\\333"); }//Û else if (int(Row[i]) ==‐64) { fprintf(PtrOut,"\\277"); }//¿ else if (int(Row[i]) ==‐97) { fprintf(PtrOut,"\\374"); }//¿ else if (int(Row[i]) ==‐96) { fprintf(PtrOut,"\\254"); }//¿ else if (int(Row[i]) ==‐113) { fprintf(PtrOut,"\\350"); }//è else if (int(Row[i]) ==‐14) { fprintf(PtrOut,"\\332"); }//Ú else if (int(Row[i]) ==‐22) { fprintf(PtrOut,"\\315"); }//Í else if (int(Row[i]) ==‐125) { fprintf(PtrOut,"\\311"); }//É else if (int(Row[i]) ==‐25) { fprintf(PtrOut,"\\301"); }//Á else if (int(Row[i]) ==‐18) { fprintf(PtrOut,"\\323"); }//Ó else if (int(Row[i]) ==‐107) { fprintf(PtrOut,"\\357"); }//I else if (int(Row[i]) ==‐85) { fprintf(PtrOut,"\\264"); }//´ else if (int(Row[i]) ==‐95) { fprintf(PtrOut,"\\272"); }//´ else if (int(Row[i]) ==‐56) { fprintf(PtrOut,"\\273"); }//>> else if (int(Row[i]) ==‐43) { fprintf(PtrOut,"\\047"); }//>> else if (int(Row[i]) ==‐124) { fprintf(PtrOut,"\\321"); }//Ñ else if (int(Row[i]) ==‐48) { fprintf(PtrOut,"\\255"); }//Ñ else if (int(Row[i]) ==‐91) { fprintf(PtrOut,"\\267"); }//Ñ else if (int(Row[i]) ==‐46 | int(Row[i]) ==‐45) { fprintf(PtrOut,"\\042"); }//Ó else if (CharAcounte == 40 | CharAcounte == 41 ) { fprintf(PtrOut,"\\%c",CharAcounte); } else if (CharAcounte == 92) { fprintf(PtrOut,"\\%c",CharAcounte); } else { fprintf(PtrOut,"%c",CharAcounte); } } fprintf(PtrOut,")\n["); /*Condicion a Buscar el la Extraccion Ojo con el S.O.*/ for(i=0;i<L;i++) //Imprimimos las metricas { AuxF = Metrics[i]; if(Metrics[i] != 0.0) { if(E < LongArchivo) { if (i == 0 && E == 0) { ValOcu = LongArchivoExt; } else {ValOcu = (int) RowExt[E‐1]; if(ValOcu == ‐121) { ValOcu = 135; } //Imprimira en recuperacion la 'a if(ValOcu == ‐114) { ValOcu = 142; } //La 'e if(ValOcu == ‐110) { ValOcu = 146; } //La 'i if(ValOcu == ‐105) { ValOcu = 151; } //La 'o if(ValOcu == ‐100) { ValOcu = 156; } //La 'u if(ValOcu == ‐25) { ValOcu = 231; } //Imprimira en recuperacion la 'A 76 genera nueva pagina... if(ValOcu == ‐125) { ValOcu = 387; } //La 'E if(ValOcu == ‐22) { ValOcu = 746; } //La 'I if(ValOcu == ‐18) { ValOcu = 750; } //La 'O if(ValOcu == ‐14) { ValOcu = 498; } //La 'U if(ValOcu == ‐106) { ValOcu = 150; } //La 'ñ } ValOcu = abs(ValOcu); if(ValOcu < 10) { if (ValOcu) fprintf(PtrOut,"%.3f00%i\t",Metrics[i],ValOcu); else fprintf(PtrOut,"%.6f\t",Metrics[i]); } else if (ValOcu < 100 && ValOcu >= 10) { if (ValOcu) fprintf(PtrOut,"%.3f0%i\t",Metrics[i],ValOcu); else fprintf(PtrOut,"%.6f\t",Metrics[i]); } else { if (ValOcu) fprintf(PtrOut,"%.3f%i\t",Metrics[i],ValOcu); else fprintf(PtrOut,"%.6f\t",Metrics[i]); } } else { fprintf(PtrOut,"%.6f\t",Metrics[i]); } E++; } } fprintf(PtrOut,"] xshow\n"); fprintf(stdout,"."); } if((L>0) | (Buffer[j‐Ajuste]==ENTER) | (Buffer[j‐Ajuste]==LF)) Ypos ‐= RowSpacing‐0; if (Ypos<ButtonMargin) // si la posicion actual esta muy abajo... { Npage += 1; Ypos=AltoHoja‐TopMargin; fprintf(PtrOut,"\n\nshowpage\n%%%%Page: %d %d\n",Npage,Npage); // } } while(PtrBuffer < LongArchivo); fprintf(PtrOut,"\n\nshowpage\n\n"); fprintf(stdout,"."); //Escribimos el numero de paginas... rewind(PtrOut); //Regresamos al principio del archivo... sprintf(Number,"%i",Npage); fseek(PtrOut,25,SEEK_SET); fprintf(PtrOut,"%s",Number); fclose(PtrOut); // Liberamos la memoria utilizada*/ FileIn = NULL; FileOut = NULL; FileExt = NULL; Buffer = NULL; Row = NULL; RowLatin = NULL; Metrics = NULL; free(FileIn); free(FileOut); free(FileExt); 77 free(Buffer); free(Row); free(RowLatin); free(Metrics); fprintf(stdout,"."); fprintf(stdout, "\nHecho...\n\n"); DefParametros++; } } } /* *** Final de codigo *****************************/ using namespace std; /* clase que contiene la información de un archivo y la posición del siguiente si hay */ class Archivo {public: Archivo(char * nombre) { nombreArchivo=nombre; apArchivoSiguiente=NULL; } ~Archivo(); char * mostrarNombreArchivo() { return nombreArchivo; } void apAsignarSiguiente(Archivo * siguiente) { apArchivoSiguiente=siguiente; } Archivo * apDevolverSiguiente(Archivo * siguiente) { return apArchivoSiguiente; } private: char * nombreArchivo; //hace referencia al siguiente archivo. El ultimo, siempre tiene valor NULL Archivo * apArchivoSiguiente; }; /* Cada clase Archivo, contiene el nombre del archivo y un apuntador a la siguiente clase Archivo. La ultima clase Archivo, apunta a NULL. Archivo Archivo ********************** |‐‐********************** |‐‐NULL * nombrearchivo * | * nombrearchivo * | ********************** | ********************** | * apArchivoSiguiente *‐‐‐ * apArchivoSiguiente *‐‐‐ ********************** ********************** */ /* clase que a partir de un directorio, genera tantas clase Archivo como archivos contenga el directorio */ class Directorio { public: Directorio(char * nombreDir) { nombreDirectorio=nombreDir; apArchivoInicial=NULL; } ~Directorio(); int leerDirectorio(); void mostrarArchivos(char *ArchivoAOcultar); private: //contiene el nombre del directorio a leer char * nombreDirectorio; //contiene un apuntador a la clase archivo con el primer archivo que se lee Archivo * apArchivoInicial; //contiene un apuntador a la clase archivo con el al ultimo archivo guardado Archivo * apArchivo; }; int Directorio::leerDirectorio() { DIR * dir; struct dirent * fichero; int long unsigned RNA; //Recorre el Nombre del Archivo int short unsigned pE; //Puntero de Extensi'on char Extension[4]; /* 78 * fichero‐>d_name Nombre del fichero * fichero‐>d_type determina el tipo de fichero */ //abrimos una instancia al directorio dir=opendir(nombreDirectorio); Archivo * apTemporal; //si devuelve null, es que ha habido algun error if (dir!=NULL) { //bucle para leer todos los archivos del directorio while (fichero=readdir(dir)) { //si NO es un directorio... if(fichero‐>d_type!=DT_DIR) { pE = 0; for( RNA=0; RNA <= strlen(fichero‐>d_name)‐1; RNA++) if (RNA >= strlen(fichero‐>d_name)‐4 ) { if (fichero‐>d_name[RNA] >= 'a' && fichero‐>d_name[RNA] <= 'z') Extension[pE] = fichero‐>d_name[RNA] ‐ 32; else Extension[pE] = fichero‐>d_name[RNA]; pE++; } Extension[4] = '\0'; if(!strcmp(Extension, ".TXT")) { if(apArchivoInicial==NULL) {//no hay todavia ningun fichero añadido apArchivoInicial=new Archivo(fichero‐>d_name); apArchivo=apArchivoInicial; } else { //ya hay algun fichero introducido //apTemporal es igual apArchivo apTemporal=apArchivo; //se genera una nueva instancia de la case con el nuevo nombre apArchivo=new Archivo(fichero‐>d_name); //al apuntador anterior se le asigna el valor del nuevo archivo apTemporal‐>apAsignarSiguiente(apArchivo); } } } } closedir(dir); return 1; } else { closedir(dir); cout << "no se ha podido abrir el directorio: " << nombreDirectorio << endl; return 0; } }; void Directorio::mostrarArchivos(char *ArchivoAOcultar) { char *DNombreDeUnArchivo; //si tiene por lo menos un archivo if(apArchivoInicial!=NULL) { Archivo * apArchivoListado; //apArchivoListado toma el valor inicial. apArchivoInicial apunta al primer archivo introducido apArchivoListado=apArchivoInicial; //vamos leyendo los diferentes archivos, hasta que lleguemos al ultimo. En el ultimo, apArchivoSiguiente apunta a NULL while(apArchivoListado‐>apDevolverSiguiente(apArchivoListado)!=NULL) { DNombreDeUnArchivo = apArchivoListado‐>mostrarNombreArchivo(); cout << DNombreDeUnArchivo << endl;//mostramos el nombre del archivo txt2ps(nombreDirectorio, DNombreDeUnArchivo, DNombreDeUnArchivo, ArchivoAOcultar); //apArchivoListado coje el valor del siguiente archivo introducido apArchivoListado=apArchivoListado‐>apDevolverSiguiente(apArchivoListado); } 79 DNombreDeUnArchivo = apArchivoListado‐>mostrarNombreArchivo(); cout << DNombreDeUnArchivo << endl; //al salir del while porque apArchivoSiguiente vale NULL, todavia no hemos mostrado el valor del archivo en si txt2ps(nombreDirectorio, DNombreDeUnArchivo, DNombreDeUnArchivo, ArchivoAOcultar); } }; int EsArchivo(char * xRuta) { int long unsigned iRNA; //Recorre el Nombre del Archivo int short unsigned ipE; //Puntero de Extensi'on char iExtension[4]; ipE = 0; for( iRNA=0; iRNA <= strlen(xRuta)‐1; iRNA++) if (iRNA >= strlen(xRuta)‐4 ) { //cout <<"{"<<fichero‐>d_name[RNA]<<"}"; if (xRuta[iRNA] >= 'a' && xRuta[iRNA] <= 'z') iExtension[ipE] = xRuta[iRNA] ‐ 32; else iExtension[ipE] = xRuta[iRNA]; ipE++; } iExtension[4] = '\0'; if(!strcmp(iExtension, ".TXT")) return 1; //cout << "Se vera un archivo" << endl; else return 0; } int main(int argc, char * argv[]) { //argc = 3; //argv[1] = "./DirAbel/EstudioArte.txt"; //argv[2] = "./DirAbel/Ocultar.txt"; //cout<<"Establecer Valores nuevos al formato? S/N N = Default"<<endl; bool i; Directorio * apDirectorio; if(argc >= 2) { if(!EsArchivo(argv[1])) { apDirectorio = new Directorio(argv[1]); //leemos el directorio i=apDirectorio‐>leerDirectorio(); } else { cout <<endl<< "Procesamos un archivo ..." << endl; txt2ps("", argv[1], argv[1], argv[2]); } } else { apDirectorio = new Directorio("./"); cout << "Argumentos: " << argc << endl; //leemos el directorio i=apDirectorio‐>leerDirectorio(); }//Mostramos los archivos leidos si no ha habido ningun problema //if(argc >= 2) //{ if(!EsArchivo(argv[1])) { if(i) apDirectorio‐>mostrarArchivos(argv[2]); } //} //free(ParametroX); cout << endl <<"Listo!, Proceso terminado ...." << endl; //cout << argv[1] << endl << argv[2] << endl; return 0; } 80 Código Fuente del Extractor /* Info ******************************************************* File: main(int *argc, char*argv[]) Descripcion: Main. Author: Mario Gonzalez Lee. / mglee@cablevision.net.mx Author: Cano JimÈnez Anel. / k3r63r05@gmail.com Date: 20/Sep/2008 Version: $ 1.00 mglee 19/Sep/2008 ‐Implementacion funcional $ 1.10 acanoj 12/Dic/2009 ‐Implementacion funcional //TODO: Implementar generacion de marca de agua, implementar la insercion de la marca... */ //{ /* Incluimos librerias de proposito general y especifico */ #include <stdio.h> #include <string.h> #include <stdlib.h> #include <math.h> #include <sys/stat.h> #include <time.h> /* Incluimos librerias propietarias ( definiciones y metricas ) */ #include "definiciones.h" #include "TimesNew.h" //} int main(int *argc,char *argv[]) /* Rutina principal */ { // Definiciones de proceso*/ FILE *PtrIn, *PtrOut; /* Apuntadores al los archivos*/ char *FileIn, *FileOut; struct stat file; char *Buffer, Number[50]; unsigned long int R,P,N,LongArchivo, Max; // Interpretacion de parametros de la linea de comandos */ FileIn = argv[1]; FileOut = argv[2]; if (FileIn == NULL) { fprintf(stdout,"\nNo se ha especificado el archivo PS de entrada"); //FileIn = "EstudioArte.txt.ps"; } if (FileOut == NULL) { fprintf(stdout,"\nNo se ha especificado el archivo TXT de Recuperación"); //FileOut = "ProgramaOculto.txt"; } // Comercial */ fprintf(stdout,"\nCopyright(c) 2009 por Mario Gonzalez Lee && Cano JimÈnenez Abel.\nGrupo de Esteganalisis\nIPN\n"); fprintf(stdout,"\nArchivo de entrada: %s\nArchivo de salida: %s\n",FileIn,FileOut); PtrIn=fopen(FileIn,"r"); // Abrimos al archivo para lectura... if (!PtrIn) /*Desplegamos mensaje de error y salimos de la aplicacion...*/ { fprintf(stderr,"ERROR: El archivo %s no se encontro o no existe...\n",FileIn); } else /*Procesamos al archivo*/ { stat(FileIn,&file); // verificamos el tamanio del archivo... LongArchivo = file.st_size; fprintf(stdout,"\nLongitud de Archivo: %i\\n",LongArchivo); Buffer = (char *) calloc(LongArchivo,sizeof(char)); // Reservamos memoria para el Buffer if(Buffer==NULL) {/* Si no se ha podido reservar memoria... */ 81 fprintf(stderr,"ERROR: No se ha podido reservar memoria...\n"); //N=NULL; //Marca Warning en Windows N=0; } else N = fread(Buffer,sizeof(char),LongArchivo,PtrIn); /* Leemos los datos al Buffer */ if (!N) {/* Si no se han leido datos en el archivo... */ fprintf(stderr,"ERROR: El archivo %s no se puede leer o no contiene datos.\n",FileIn); free(Buffer); } else { //*********************************************************************************** /*Estamos Listos par Buscar la Info Estego y Recuperarla en el archivo de salida*/ PtrOut = fopen(FileOut,"w"); /*Alisto el archivo de salida*/ //fprintf(PtrOut,"Recuperardo por: Cano JimÈnez Abel\n"); fprintf(stdout,"\nArchivo PS Cargado...\n"); int PosX = 0; int Ind = 0; P = 0; R = 0; Max = 1; Ind = 0; //Vaciamos el Arreglo de recuperaci'on para el numero while(Ind <= 50) { Number[Ind] = '\0'; Ind++; } Ind = 0; while(PosX <= LongArchivo) {if (PosX+4 <= LongArchivo) /*Aseguramos que haya tres caracteres mas*/ { if(Buffer[PosX] == ')' && Buffer[PosX+1] == '\n' && Buffer[PosX+2] == '[' ) { PosX = PosX + 4; while(PosX <= LongArchivo && Buffer[PosX] != ']' && P <= Max) /*Leeremos hasta encontrar un ] y Indique el Maximo de caracteres que se transportan*/ {if( ( int(Buffer[PosX]) ‐ 48 >= 0 && int(Buffer[PosX]) ‐ 48 <= 9 ) || Buffer[PosX] == '.' ) {//fprintf(stdout,"[%i]", int(Buffer[PosX])‐48); /*Capturamos el Valor numerico*/ Number[Ind] = Buffer[PosX]; Ind++; } else if (Buffer[PosX] == '\t') {//if (Ind >= 8) {Number[Ind] = '\0'; } while(Number[R] != '.') /*Usamos el '.' que debe de venir en la metrica*/ R++; //A partir de donde este el punto, recorremos las posiciones. //Pero recorremos 3 posiciones, que son las primeras 3 decimas //que no se toman en cuenta para transportar valores. Number[R+0] = Number[R+1]; Number[R+1] = Number[R+2]; Number[R+2] = Number[R+3]; Number[R+3] = '.'; //Finalmente haremos Ceros hasta donde este el punto R = 0; while(Number[R] != '.') /*Usamos el '.' que debe de venir en la metrica*/ { Number[R] = '0'; R++; } Number[R] = '0'; R = 0; Number[Ind+1] = '\0'; /*Terminamos de capturar el n'umero*/ Ind = 0; if(P) { fprintf(stdout,"%c",atoi(Number)); fprintf(PtrOut,"%c",atoi(Number)); } else { //fprintf(stdout,"P %i Largo %i\n", P, atoi(Number)); fprintf(stdout,"Texto Recuperado:\n", P, atoi(Number)); Max = atoi(Number); } Ind = 0; //Vaciamos el Arreglo de recuperaci'on para el numero 82 while(Ind <= 50) { Number[Ind] = '\0'; Ind++; } Ind = 0; P++; } else { fprintf(stdout,"%c", Buffer[PosX]); PosX = PosX + 1; } } } PosX = PosX + 1; } rewind(PtrOut); // Regresamos al principio del archivo... fseek(PtrOut,25,SEEK_SET); fclose(PtrOut); //{ /* Liberamos la memoria utilizada*/ free(Buffer); fprintf(stdout, "\nHecho...\n\n"); } } return 0; } /* *** Final de codigo *****************************/ } 83