View/Open


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,
[email protected]
Mohammad
Shirali‐Shahreza,
Computer
Science
Department,
Sharif
University
of
Technology,
Tehran,
IRAN,
[email protected]
Steganography
in
MMS.
Mohammad
Shirali‐Shahreza,
Computer
Science
Department,
Sharif
University
of
Technology,
Tehran,
IRAN,
[email protected]
An
Evolution
of
Hindi
Text
Steganography
Kalavathi.Alla,
Christu
Jayanthi
Jubilee
College,
[email protected]
Dr.
R.
Siva
Rama
Prasad,
Acharya
Nagarjuna
University,
[email protected]
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.
/
[email protected]
Author:
Cano
JimÈnez
Anel.
/
[email protected]
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