jueves, 30 de diciembre de 2010

Una de esteganografía

Un tema que me apasiona es el del arte y ciencia de ocultar información.

Para ello disponemos de técnicas criptográficas que están muy avanzadas y que nos proporcionan algoritmos a día de hoy seguros e irrompibles.

Lo que ocurre es que cuando uno ve una codificación extraña de símbolos, automáticamente sabe que la intención del remitente es la de ocultarnos el mensaje.

Pero ¿Cómo podríamo hacer lo mismo pero haciendo que el mensaje pasase totalmente desapercibido por los ojos de curiosos?...

La respuesta a esta pregunta nos la da la 'esteganografía' y que como burda definición podriamos decir que es "escritura encubierta", en contraposición a la criptografía, que podríamos definirla como "la transformación de un mensaje legible en uno ilegible por nadie, excepto por el receptor".

Un ejemplo clásico de esteganografía empleado ya en tiempos remotos sería la famosa escritura en papel con tinta invisible (zumo de limón).

Trataré de explicar someramente dos técnicas básicas esteganográficas y veremos algun que otro ejemplo, para ello y acorde con nuestros tiempos usaremos archivos de imágen como contendor para ocultar nuestro mensaje, pero podrían ser otras extensiones como audio, etc.

La imagen de origen sera esta:


Una foto cándida de mi chiquitín y yo en la ciudad más bella del mundo (Salamanca), que nos servirá de contenedor de mensajes y/o archivos ocultos.

La primera técinica es por EOF (End Of File) o Fin De Fichero y que básicamente consiste en insertar el mensaje (en crudo o cifrado) al final del fichero.

Como ejemplo pondré el mensaje secreto justo al final del archivo origen que como sabemos tiene extensión PNG y el EOF nos lo dá la marca "IEND".

Así es como quedaría la imagen con el mensaje secreto:



Ahora el receptor de mensaje solo tendrá que editar la imagen con un editor hexadecimal y voilá.



Como se observa el mensaje está en crudo, pero si hubiesemos utilizado cualquier algoritmo criptográfico moderno el resultado sería totalmente imperceptible por el "enemigo". 

Un ejemplo de esto último se podría hacer con un cifrado básico e inseguro como el cifrado XOR con clave "eternoAprendiz" y cuyo resultado sería esto otro:


La segunda técnica es un poco más elaborada y por eso es también la más usada y se denomina "LSB (Less significant byte)" o inserción del último bit menos significante.

Como todos sabemos, una imagen está compuesta por una matriz de píxeles. 
Cada pixel se construye con tres bytes. 
Cada byte codifica un color básico (rojo, verde, azul) en un escala de 0 a 255, de manera que si queremos codificar un pixel con el color blanco pues pondríamos cada byte con valor máximo (255) o si por el contrario quisiéramos codificar el pixel con el color negro, pues pondríamos cada byte con valor mínimo (0) y así jugando con la mezcla de estos tres byte conseguiremos los 16 millones de colores que podemos formar.

Pues la mágia de esta segunda técnica es aprovecharse de los bits menos significativos de cada byte de un pixel para codificar el mensaje.

El resultado es una nueva imagen con colores distintos a la original pero que para el ojo humano es inapreciable.

Como hacer esto último a mano es tedioso, lo que haremos es usar una aplicación openSource, desde mi punto de vista excelente, que se llama OpenStego

Esta vez ocultaremos un fichero de texto, con un mensaje secreto y que dejo a los lectores que hagan el paso inverso par leer dicho mensaje secreto.



El resultado es esta otra imagen:



Logicamente no solo podremos incrustar mensajes de texto, sino cualquier formato binario que se nos ocurra, desde otra imagen, a un audio, video, pdf, zip, ....y hasta el infinito y más allá.

La esteganografía además nos permite incrustar nuestra propia huella digital (fingerPrint). Pensemos que algún día elaboramos algún trabajo que alguien nos plagia, pues si a ese trabajo le hemos incrustado nuestra huella tendremos todo de nuestra parte para demostrar que el trabajo es nuestro.

Para finalizar dedico este post íntegramente a mi gran amigo Alberto (Magic). Va por ti maestro.

sábado, 11 de diciembre de 2010

El Principio de Pareto

Si alguna vez te has preguntado:

Si me esfuerzo tanto ¿Por qué obtengo tan pocos resultados? 

Entonces amigo mio, el principio del pareto quizás dispe tu duda.

Este principio empírico, observado y enunciado por Vilfredo Pareto, es utilizado en múltiples disciplinas, entre las  que se encuentran la ingeniería del software y que viene a decir algo así como:



"el 80% del esfuerzo de desarrollo (en tiempo y recursos) produce el 20% del código, mientras que el 80% restante es producido con tan sólo un 20% del esfuerzo"
"El 80% de los resultados proviene del 20% del esfuerzo"
o
"Probar el 20% del código elimina el 80% de los fallos"
o
"El optimizar el 20% del código origina un 80% de mejora del rendimiento".

Como se menciona anteriormente esto es una regla de sentido común que se ajusta bastante a la realidad.

No obstante te recomiendo que amplíes horizontes consultando los siguientes artículos:

viernes, 12 de noviembre de 2010

Neque porro quisquam est qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit...

Es posible que en nuestro día a día surgan ocasiones en las que tengamos que eleborar o maquetar algún tipo de aplicación, web, incluso crear algún tipo de letra... resumiendo, que tengamos que teclear bastante cantidad de texto y además sin saber que poner.

Pués bien, para estos menesteres existe un texto que de seguir así se va a convertir en estandar de facto "si es que ya no lo es" y cuya denominación es Lorem Ipsum.

Es un texto sin sentido ni significado, derivado del latín y proveniente de la obra de Cicerón (45 a. C.).

Un ejemplo podría ser este:

"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Etiam vestibulum cursus nisi, in luctus lacus aliquet a. Vestibulum nisl odio, tincidunt sit amet molestie pretium, tempor id odio. Phasellus cursus arcu at leo lacinia in eleifend erat consequat. Nunc dui nulla, feugiat et imperdiet iaculis, fermentum in urna. Integer lacinia mattis enim, vel tempus metus vestibulum eu. Sed sed consequat felis. Morbi id nunc quis lacus accumsan dignissim a a nisl. Sed auctor aliquet mauris, ut auctor tortor placerat ut. Nullam eget erat metus. Donec feugiat magna sit amet lorem hendrerit nec laoreet sapien lobortis. Suspendisse egestas nibh nunc. Ut at consectetur nisl. Maecenas sagittis sapien gravida urna tempor luctus. Nulla vitae porttitor lectus. Maecenas sagittis ultrices augue, malesuada eleifend nisi feugiat in. Duis sagittis."

No deja de llamarme la atención la similitud en cuanto a la acción de Lorem Ipsum con aquel pangrama que tantas veces hemos visto en windows cuando queremos ver como de bien queda un font:

"El veloz murciélago hindú comía feliz cardillo y kiwi".

No degeis de leer estos enlaces para ampliar vuestros conocimientos:
Con todo esto y un poco de imaginación, el que rellena texto inutil a mano es porque quiere.

martes, 26 de octubre de 2010

¿Metemos los bits en una cripta?

Soy consciente que con este post, más de uno de mis compañeros de trabajo me va a negar la palabra en lo que me reste de existencia, pero que quereis que os diga, o lo suelto o exploto.

El término ENCRIPTAR, NO EXISTE, en su lugar el termino que debemos emplear es CIFRAR.

De la misma manera ocurre con el paso inverso, DESENCRIPTAR NO EXISTE en su lugar el término que debemos emplear es DESCIFRAR.

Veamos que dice el DRAE sobre la palabra ENCRIPTAR:
  • La palabra encriptar no está en el Diccionario.
y sobre CIFRAR:
  • Transcribir en guarismos, letras o símbolos, de acuerdo con una clave, un mensaje cuyo contenido se quiere ocultar.
Todo este embrollo viene porque en inglés "cifrar" es "encrypt", y venga nosotros lo convertimos a spanglish por que si.

Lo que más me molesta es que sencillamente lo decimos mal porque quien nos enseñan estas cosas también las dicen mal (profesores, medios de comunicación, peliculas, etc).

Vamos a hacer todos un esfuerzo y a intentar decir las cosas por su nombre.

Espero que despues de todo esto no me encripteis, es decir, no me metais en la cripta ;)

Saludos.

lunes, 25 de octubre de 2010

Chat P2P en JAVA

Proyecto que desarrollé en NetBeans para el club mentes inquietas, y que faclilita el aprendizaje y práctica de diversas técnicas tales como:

  • Programación en JAVA.
  • Programación con Sockets TCP.
  • Programación concurente.
  • Protocolos y Serialización de datos.
  • Cifrado y codificación de datos.
  • Modelo de programación cliente-servidor.
  • ...

He intentado buscar la simplicidad en todo el proyecto para que se entiendan bien todos los conceptos, ya que cuando uno se enfrenta a una arquitectura cliente servidor  por primera vez, suele ser algo doloroso si no tenemos quien nos guíe. 

Ejemplos de este tipo hay muchos, pero que en la misma aplicación convivan servidor y cliente, no hay tantos.

He de recordar que dentro del proyecto existe un módulo "Base64Coder.java" que pertenece a Christian d'Heureuse y que no estaría nada mal que supieseis bajo que licencias se encuentra. Este modulo es el encargado de la codificación en base 64 que se utiliza en el proyecto.

Anexo además un presentación con definiciones que ayudarán a comprender un poco mejor de que va todo esto.

Descargas:

sábado, 4 de septiembre de 2010

Efecto JUDDER

Hoy me decido por comentar de pasada, un defecto que presentan la gran mayoría de los televisores HD que tanto calado están teniendo en nuestros días.

Nos encontramos un sabado por la tarde-noche, dispuestos a ver una película en alta definición, con grandes paisajes panorámicos y muchíiisima acción, pongamos por ejemplo X-MEN o Avatar.

Por el momento todo es perfecto, palomitas, cocacola, un ambiente de cine y de repente...¡¡ Cómo !!, !! Qué !! la película da pequeños tironcitos en las escenas de movimiento de cámara laterales.

Piensas, bueno, quizás sea cosa de la película o del PC que se habrá puesto a hacer un escaneo con el antivirus... al final descubres que te pasa en todas las películas que tienes HD y que ya se te ha formado un tic nervioso en la ceja derecha  de aguantar, por un lado lo tironcitos de tus pelis preferidas y por otro a tu mujer diciendote "si ya lo decía yo, tanta tecnología y al final no vale para nada, sólo para sacarnos el dinero".

Pues bien el problema en cuestión se llama "efecto judder" y es consecuencia de la desigualdad entre los fotogramas por segundo (fps) a los que se ha grabado la película y la frecuencia de refresco de la pantalla (Hz).

Los videos en alta definición se muestran a 24 fotograma (frame) por segundo, y la mayoría de monitores y   televisores se mueven en rangos de 50, 60, 100 y 120 Hz, de manera que por cada segundo se muestran dos veces cada fotograma. 

Para pantallas de 50hz: 24 x 2 = 48 (faltan dos fotogramas por sincronizar).
Para pantallas de 60hz: 24 x 2 = 48 (faltan doce fotogramas por sincronizar).

El televisor sincroniza repitiendo los fotogramas inmediatamente anteriores, produciendo el tan molesto efecto judder.

La cuestion es, por un lado ¿Por que los fabricantes no avisan de esto? y por otro ¿Se puede corregir este desfase?

La primera cuestión es obvia, motivos económicos. Si los fabricantes avisasen de esto, no venderían ni un solo televisor / monitor HD.

En cuanto a la segunda, afortunadamente si que tiene solución en la mayoría de los casos y siempre que nuestra salida de vídeo pueda sacar la señal a 1080p y 24 fps y nuestro televisor puede manejar refrescos de 24 hz o múltiplos de este (48, 72, etc).



Evidentemente todo lo anterior es extrapolable a videos de 25, 26 y 27 fps y demás reproductores hd como reproductores hd, bluray, xbox, ps3, etc.

Un articulo más técnico y mejor explicado lo podéis encontrar en la revista on/off.

miércoles, 21 de julio de 2010

¿Realmente se borran los ficheros?

Todos sabemos que al borrar un archivo o directorio podemos hacerlo de dos maneras:
  1. Enviar el archivo a la papelera de reciclaje y en caso de borrado accidental tener la posibilidad de recuperación.
  2. Borrar el archivo permanentemente sin pasar por la papelera de reciclaje y no tener posibilidad de recuperación ante un borrado accidental.

Esto seguro que todos lo sabeis, pero lo que no todos sabeis es que por defecto, en la segunda opción, no se borran físicamente los archivos.

Básicamente el sistema operativo mantiene unas tablas de índices de archivos, que no son más que apuntadores al comienzo de la cabecera de cada archivo y cuando se da la orden de borrar, en realidad lo que se hace es borrar esos índices y marcar el sector como libre para su posterior utilización si así fuese necesario.

Debido a esto y como se intuye, es posible recuperar archivos que en un principio parecían estar borrados, de una manera facilísima.

Esto en derterminadas ocasiones puede ser una ventaja, pero en otras puede ser un inconveniente, de hecho un estudio denominado “A remembrance of data passed" realizado por el MIT (Massachusetts Institute of Technology), analiza un total de 158 unidades de disco duro adquiridas a través de la web de subastas de eBay, en tiendas informáticas, empresas e intercambios.

El informe destaca que:
  • El 74% de los discos contenían antiguos datos que se podían recuperar y leer. 
  • El 17% contenían sistemas operativos totalmente instalados y operativos con datos de usuario.
  • Un 57% de los discos habían sido formateados, pero todavía contenían datos antiguos recuperables. 
  • Sólo el 12% habían sido adecuadamente limpiados antes de ponerlos a la venta.
  • 29 de los 158 discos analizados no funcionaban.

Entre la información recuperada de estos discos encontraron:
  • Registros financieros empresariales.
  • Datos personales.
  • Información médica.
  • Cartas de amor. 
  • Gbytes de e-mail personales. 
  • Pornografía. 

Los archivos de registro de uno de los discos proporcionaron lo que parecía ser un total de 2.868 números de tarjetas de crédito y cuentas bancarias, fechas de transacciones y balances. Los que han realizado este estudio creen que quizá este disco proviniera de un cajero automático que nadie se había molestado en limpiar.

Esta situación puede llegar a ser problemática en algunos casos. Un usuario podría estar utilizando un disco de segunda mano formateado y aparentemente “limpio” sin saber que existen archivos de pornografía infantil “escondidos” pero recuperables con ciertas herramientas. 

La fuente de esta información la podréis ver completa en este enlace:


Por este motivo y sobre todo para que a mis más allegados no les inunde un alto grado de paranoia, en especial a "mi hermana", voy a comentar brevemente como se puede evitar esto haciendo uso de aplicaciones de terceros.
  • Para paltaformas recomiendo Eraser, que es una herramienta avanzada de seguridad que te permite eliminar completamente los datos sensibles de tu disco duro, sobreescribiendo varias veces con patrones cuidadosamente seleccionados. Es un software gratuito y su código fuente está liberado bajo GNU (General Public License).


Posiblemente es un próximo post veamos como recuperar ficheros haciendo uso de herramientas próximas a la informática forense.


domingo, 20 de junio de 2010

Prácticas de Sistemas Operativos II, curso 2009/10

Estas son las cuatro prácticas que he realizado para la asignatura de sistemas operativos II y que desde mi punto de vista son esenciales si se quiere tener una buena comprensión de este tipo de sistemas (UNIX, Linux).

Se nota que el equipo docente resalta aquellas partes que son bastante importantes en el estudio de esta asignatura, sobre todo en lo referente a procesos (creación, control, comunicación, sincronización, etc).

Las prácticas están hechas en C, cosa lógica si recordamos que gran parte de UNIX / Linux así fueron construidos.  




Descargas:

martes, 18 de mayo de 2010

Apuntes de la asignatura de Sistemas Operativos II, curso 2009/10

Estos son los apuntes que he realizado para esta asignatura que tanto me ha gustado.

Me maravilla el software libre y en especial LINUX, pero reconozco que esta asignatura me ha ayudado mucho para comprender en mediana profundidad como está construido esta maravilla de sistema operativo, y que seguro es el principio de un largo camino que aun me queda por recorrer.

En Sistemas Operativos I se ven los fundamentos en general resultando dificultosa, puesto que no se puede observar lo que se estudia más allá de la teoría, pero en esta segunda parte es todo lo contrario.

Ejemplos escritos en ANSI C desde el primer momento que se empieza a estudiarla de creación  y sincronización de procesos mediante señales y mecanismos IPC, gestión de la memoria, sistema de ficheros, etc... un gustazo.

En próximos post subiré las cuatro prácticas que han pedido en este curso y que no tienen desperdicio.

Descargas:
  • Tema 2: Consideraciones generales del sistema operativo UNIX.
  • Tema 4: Estructuración de los procesos en UNIX.
  • Tema 5: Control de procesos en UNIX.
  • Tema 6: Planificación de procesos en UNIX.
  • Tema 7: Comunicación y sincronización de de procesos en UNIX.
  • Tema 8: Sistema de archivos en UNIX.
  • Tema 9: Gestión de memoria en UNIX.

jueves, 13 de mayo de 2010

Hace tiempo que vengo diciendo las ventajas que nos ofrece el uso de la "nube" y lo que ahora traigo da fe de ello.

WingedBox es un servicio para compartir ficheros a través de Internet. 

Con WingedBox tienes:
  • Acceso a tus ficheros estés donde estés.
  • Acceso a los ficheros de tus amigos.
  • Posibilidad de compartir sin restricciones.
  • 2Gb de almacenamiento gratuito.

Con WingedBox tienes una forma de compartir ficheros entre amigos donde nada más entrar puedes echar un vistazo a lo que éstos van compartiendo (un vídeo, una canción, un album de fotos de un viaje).

Date de alta y mira por tí mismo las distintas opciones. 

Cosas que ya están funcionando:
  • Interfaz web.
  • Interfaz web para móviles (ya puedes subir ficheros desde Opera Mobile y Opera Mini en tu  Symbian/Android/iPhone).
  • Compartir ficheros en Twitter/Facebook desde la página de WingedBox.
Cosas que están por venir:
  • Aplicación para Android para subir ficheros desde el teléfono.
  • Aplicación para Facebook para subir ficheros a la red social.
Para más información visita la página about del proyecto.

Este desarrollo ha sido realizado gracias a javiyu y kiko por lo que no estaría nada mal mandarles nuestros comentarios a cerca de esta maravilla que nos ofrecen.

Para finalizar quiero decir que es un orgullo el tener como compañeros de trabajo a estas dos máquinas de la programación.

Desde mi blog os deseo toda la suerte del mundo.

viernes, 7 de mayo de 2010

Práctica de la asignatura Estructura y Tecnología de los Computadores III

Asignatura muy bonita y de las que recuerdo con cariño. Sobre todo por que el E.D. es de los que de verdad se nota que están para enseñar al los alumnos.

Esta asignatura trata de enseñar un lenguaje de programación para construir hardware (VHDL) y que demuestra una vez más el ingenio de la mente humana.

En esta práctica, se nos planteaba el problema de diseñar un circuito de control para una máquina automática expendedora de dos tipos de bebida: botellas de agua y latas de refresco.

Anexo el enunciado y la memoria práctica que hice en el curso 2007 / 08:
Espero que os sea de utilidad.

miércoles, 5 de mayo de 2010

Activar plug-in Flash player en Kubuntu 10.4

Suponiendo que el plug-in de flash player se encuentra instalado en nuesto sistema los pasos a seguir son:

  • Creamos el directorio /opt/google/chrome/plugins
sudo mkdir -p /opt/google/chrome/plugins

  • Copiamos la librería en el directorio que acabamos de crear

sudo cp /usr/lib/flashplugin-installer/libflashplayer.so /opt/google/chrome/plugins/ 
Ahora solo nos falta editar el menu de  Google Chrome haciendo:
  • Click con el boton dercho en el boton de inicio KDE.
  • Click con el boton izquierdo en  "Editor de menus"
  • Desplegamos en la nueva ventana "Internet" >> "Google Chrome" y en la solapa "Genera" en el apartado "comando" escribimos:
/opt/google/chrome/google-chrome –enable-plugins %U


Con esto ya podemos disfrutar de las ventajas que nos ofrece este plug-in.


sábado, 1 de mayo de 2010

¿Qué es matroska?

Me he decidido postear sobre matroska debido principalmente a que últimamente está alcanzando bastante popularidad ya que se está convirtiendo en un estándar de facto como contenedor de archivos para la alta definición (HD).

Matrosca es un contenedor de formatos multimedia.

Un contenedor de formatos multimedia es un archivo que almacena o contiene archivos de vídeo, audio, subtítulos, capítulos, meta-datos e información de sincronización siguiendo un formato previamente establecido.

Este concepto no es nuevo, de hecho lleva entre nosotros más tiempo del que imaginamos, ¿no os suenan las siguientes extensiones de archivo?:
  • AVI
  • MPG
  • QuickTime
  • WMV 
  • Ogg 
  • OGM 
  • MP4 
  • ASF
  • RealMedia …
Entonces, ¿por qué utilizar matroska (.mkv)?.

Pues existen muchas razones:
  • Está hecho íntegramente con código abierto (open source).
  • Puede incluir una o varias pistas de vídeo, para reproducir una después de otra.
  • Puede incluir una o varias pistas de audio.
  • Audio y Video en VBR (BitRate Variable).
  • Varios subtítulos, incluyendo SSA/ASS con funciones avanzadas.
  • Varios capítulos en un mismo fichero.
  • Streaming en tiempo real mientras se descarga a través de Internet.
  • Búsqueda mejorada, ni desincronización ni congelación del video.
  • Los archivos tienen un peso menor al que tendrían en contenedores como OGM o AVI.
  • Facilidad para añadir extensiones futuras, gracias a EBML (Extensible Binary Meta Language).
  • Posibilidad de añadir archivos de cualquier tipo.
  • Posibilidad de empotrar una imagen en el contenedor como muestra del contenido.
  • Soporte para tags.
  • Capacidad de recuperación de errores.
Próximamente veremos como mediante herramientas hechas por los creadores de matroska podemos modificar un archivo mkv a nuestro antojo.

Para finalizar os invito a visitar las siguientes referencias:

martes, 30 de marzo de 2010

Índice TIOBE

Si alguna vez te has preguntado que lenguaje de programación es el más utilizado actualmente, o por donde van las tendencias en el desarrollo de software o simplemente quieres aprender un lenguaje de programación nuevo y no tienes claro cual podría ser. 

Pues posiblemente el El índice Comunitario de Programación TIOBE  pueda ayudarte.


En el último informe realizado de Marzo del 2010 se pueden descubrir cosas tan interesantes como que Go y Objective-C e incluso Fortran están escalando posiciones desmesuradamente.

Incluso se puede ver como después de tantos años nuestro querido C sigue en las más altas posiciones.




También podemos encontrar curiosidades como que el lenguaje más popular del 2009 fue Go.


TIOBE saca estas conclusiones contando los hits de los motores de búsqueda más populares (Google, Google Blogs, MSN, Yahoo!, Wikipedia and YouTube) con la consulta:

+"<language> programming"

Quizás no sea la mejor manera de calcular este hecho, pero cierto es que da ideas de la dinámica que siguen los desarrolladores en la actualidad.

Sin embargo te anímo a que juzgues por ti mismo.

sábado, 27 de marzo de 2010

El día que un CRC cambió mi vida parte IV

Lo prometido es deuda, finalizamos la saga del CRC con esta cuarta entrega.

En esta ocasión utilizaremos lo aprendido aplicado a un caso real.

El caso real perfectamente podría ser el acceso a un sistema o aplicación en el cual se pide un login de entrada.

Seremos capaces de distinguir si nuestra aplicación de acceso está siendo debugeada.

Si ejecutamos la aplicación cuyo source code está al final de la explicación, vemos que se nos pide un login de acceso, y como no lo tenemos, lo normal es que no podamos acceder, tal y como se muestra en la siguiente imagen:


En la próxima imagen vemos en que parte del desensamblado está la ‘zona caliente’, es decir, dónde una vez realizado el cálculo del login se compara el password que hemos introducido con el password válido y en función de la comparación darnos o no acceso al sistema:


Pues bien, justo en dónde hace la comparación pondremos un punto de ruptura y observamos como se comporta la aplicación ante este hecho:


Como veis hemos sido capaces de saber si están depurando nuestra aplicación haciendo uso de un CRC.

La explicación es muy sencilla, cuando se coloca un punto de ruptura en alguna parte del código, se manda una instrucción al debugger y este reemplaza el primer byte del código por el valor 0xCC. Este valor es el equivalente a la instrucción INT 3, la cual genera una interrupción cada vez que esta se ejecuta, pasándole el control al depurador para que detenga la ejecución normal de la aplicación. 

Como podemos intuir, previamente calculamos el CRC a la ‘zona caliente’ de nuestro código sin tener ningún punto de ruptura dándonos un valor de 0x442AE2AB, valor diferente al que se calcula cuando se puso el breakpoint tal y como se ve en la siguiente imagen:


Nuevamente vemos que el ingenio humano no tiene límites.

Para finalizar, anexo el código fuente del ejemplo:

/*****************************************************************************/
/*                                                                           */
/*  NOMBRE      : CRCy.c                                                     */
/*  AUTOR       : Longinos Recuero Bustos                                    */
/*  EMAIL       : lrecuero1@alumno.uned.es                                   */
/*  WEB         : http://longinox.blogspot.com/                              */
/*  FECHA       : 24/03/2010                                                 */
/*  LICENCIA    : GPL                                                        */
/*  DESCRIPCIÓN : Uso de un CRC como proteccion antidebug.                   */
/*                                                                           */
/*****************************************************************************/

/* INCLUSIÓN DE HEADERS ******************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* DEFINICIÓN DE CONSTANTES SIMBÓLICAS ***************************************/
#define INIT_ADDRESS 0x004013D7
#define CRC          0x442AE2AB

/* DEFINICIÓN DE TIPOS *******************************************************/

typedef enum
{
    FALSE = 0,
    TRUE
}TBoolean;

/* DEFINICIÓN DE PROTOTIPOS DE FUNCIONES *************************************/

TBoolean acceder( char *Nombre, char *Password );
void calculoCRCx( unsigned char byte, unsigned int *crc );

/* MAIN PROGRAM **************************************************************/

int main( int argc, char* argv[] )
{
 /* Definición de variables locales */
 char nombre[ 41 ];      // Nombre in.
 char password[ 60 ];    // Paswword in.
 int  i;                 // Indice del bucle.
 unsigned int   crc = 0; // CRC.
 unsigned char *p;

 /* Dirección de comienzo de la función acceder */
 p = ( unsigned char *)INIT_ADDRESS;

        /* Petición del Nombre */
 puts( "\nNombre [Max. 40 caracteres]: " );
 gets( nombre );

 /* Petición del password */
 puts( "\nPasword: " );
 gets( password );

 /* Calculamos el CRC de la zona caliente */
 for( i = 0; i < 225; i++ )
 {
  calculoCRCx( p[ i ], &crc );
 }

 if( CRC != crc )
 {
  /* Nos están depurando */
  puts( "\n\nMe estas debugeando? pues entonces ADIOS!!!!!\n\n" );
  return EXIT_FAILURE;
 }
 else
 {
  /* No estamos siendo depurados */
  if( acceder( nombre, password ) )
  {
   /* Acceso OK */
   puts( "\n\nACCESO OK!!!!! Eres un masterCraker\n\n" );
  }
  else
  {
   /* Acceso denegado */
   puts( "\n\nOPPSSSSS NO ES CORRECTO!!!!! Eres un calamardo\n\n" );
  }

  return EXIT_SUCCESS;
 }
}

/* FUNCIONES PRVADAS *********************************************************/

TBoolean acceder( char *Nombre, char *Password )
{
    char claveXOR[] = "cAlAmarDO tENtACUlO";
    unsigned int i, j, password = 1;

    for( i = 0, j = 0; i < strlen( Nombre ); i++ )
    {
        password *= ( Nombre[ i ] ^ claveXOR[ j ] ) % 0xDEADBEEF;
        password ^= 0xABADBABE;
        j = ( j + 1 ) % strlen( claveXOR );
    }

    if( password == ( unsigned int )atoi( Password ) )
    {
        return !FALSE;
    }
    else
    {
        return !TRUE;
    }
}

void calculoCRCx( unsigned char byte, unsigned int *crc )
{
    unsigned char i;
    unsigned int  polinomioGenerador  = 0x8005;
    TBoolean es_Bit_A_Uno;
    TBoolean es_MSB_CRC_A_Uno;

    /* Para cada byte del fichero... */
    for( i = 0; i < 8; i++ )
    {
     /* Se comprueba si el bit actual está a 1 */
     es_Bit_A_Uno = ( ( ( byte >> ( 7 - i ) ) & 1 ) == 1 );

        /* Se comprueba si el MSB actual del crc está a 1 */
        es_MSB_CRC_A_Uno = ( ( ( *crc >> 15 ) & 1 )  == 1 );

        *crc <<= 1;

        /* Si los booleanos son distintos uno de otro */
        if( es_MSB_CRC_A_Uno ^ es_Bit_A_Uno )
        {
         /* XOR entre el crc actual y el polinómio generador */
                *crc ^= polinomioGenerador;
        }
    }
}

Espero que os hayáis divertido tanto como lo he hecho yo con esta saga del CRC.

domingo, 14 de marzo de 2010

El día que un CRC cambió mi vida parte III

Continuamos con la saga del CRC.

En esta 3ª entrega os muestro como calcular el CRC a un fichero, utilizando CRCs estandarizados como el CRC-16 y el CRC-CCITT.

El código está hecho en C y es portable a Linux para todo aquel que lo desee.


Como podréis observar el código está contenido en un sólo módulo y es muy secuencial, con el fin de que se pueda seguir fácilmente y sin demasiadas complicaciones.

No obstante todo el que quiera aportar algo más o mejorar la aplicación, pues que lo haga sin más. Todos estamos aquí para seguir aprendiendo unos de otros.

Sin más rodeos anexo el código fuente:



/*****************************************************************************/
/*                                                                           */
/*  NOMBRE      : CRCx.c                                                     */
/*  AUTOR       : Longinos Recuero Bustos                                    */
/*  EMAIL       : lrecuero1@alumno.uned.es                                   */
/*  WEB         : http://longinox.blogspot.com/                              */
/*  FECHA       : 14/03/2010                                                 */
/*  LICENCIA    : GPL                                                        */
/*  DESCRIPCIÓN : Aplicación que calcula a un fichero un CRC estandarizado.  */
/*                                                                           */
/*****************************************************************************/

/* INCLUSIÓN DE HEADERS ******************************************************/

#include <stdio.h>
#include <stdlib.h>

/* DEFINICIÓN DE CONSTANTES SIMBÓLICAS ***************************************/

#define CRC_CCITT 0x1021
#define CRC_16    0x8005

/* DEFINICIÓN DE TIPOS *******************************************************/

typedef enum
{
 FALSE = 0,
 TRUE
}TBoolean;

/* DEFINICIÓN DE PROTOTIPOS DE FUNCIONES *************************************/

void calculoCRCx( unsigned char value, unsigned int *crc );

/* MAIN PROGRAM **************************************************************/

int main( int argc, char* argv[] )
{
 /* Se comprueba que si se ha introducido la ruta del fichero */
 if( argc > 1 )
 {
  /* Argumentos OK */
  FILE *fichero;

  /* Se obtiene el manejador del fichero */
  fichero = fopen( argv[ 1 ], "r" );

  if( fichero != NULL )
  {
   /* OK: El fichero existe */

   /* Contador de bytes leidos */
   unsigned int contador = 0;

   /* Valor inicial del CRC */
   unsigned int crc = 0;

   /* Se almcena el primer byte a tratar */
   unsigned char byte = fgetc( fichero );

   /* Mientras queden bytes por leer... */
   while( !feof( fichero ) )
   {
    contador++;

    /* Se formatea la salida */
    if( byte > 0x0F )
    {
     printf( "0x%X\t", byte );
    }
    else
    {
     printf( "0x0%X\t", byte );
    }

    calculoCRCx( byte, &crc );

    /* Se almacena el próximo byte a tratar */
    byte = fgetc( fichero );
   }

   /* Se cierra el fichero */
   fclose( fichero );

   /* Se enmascaran los 32 bits de menos peso */
   crc &= 0xFFFF;

   /* Se muestra el CRC calculado formateando la salida */
   puts("\n\n------------------- FIN -------------------\n");
   printf( "\n\tBytes leidos:\t%d\n", contador );
   printf( "\n\tCRC calculado:\t0x%X\n", crc );
   puts("\n-------------------------------------------\n");
  }
  else
  {
   /* FALLO: No exite el fichero */
   puts("\n\t¡¡¡ ERROR !!!. No existe el fichero\n");
   return EXIT_FAILURE;
  }
 }
 else
 {
  /* FALLO: No se ha introducido nugún argumento */
  puts("\n\t¡¡¡ ERROR !!!. Se necesita la ruta del fichero\n");
  return EXIT_FAILURE;
 }

 return EXIT_SUCCESS;
}

/* FUNCIONES PRVADAS *********************************************************/

void calculoCRCx( unsigned char byte, unsigned int *crc )
{
 unsigned char i;
 unsigned int  polinomioGenerador  = CRC_16;

 /* Para cada byte del fichero... */
 for( i = 0; i < 8; i++ )
 {
  /* Se comprueba si el bit actual está a 1 */
  TBoolean es_Bit_A_Uno = ( ( ( byte >> ( 7 - i ) ) & 1 ) == 1 );

  /* Se comprueba si el MSB actual del crc está a 1 */
  TBoolean es_MSB_CRC_A_Uno = ( ( ( *crc >> 15 ) & 1 )  == 1 );

  *crc <<= 1;

  /* Si los booleanos son distintos uno de otro */
  if( es_MSB_CRC_A_Uno ^ es_Bit_A_Uno )
  {
   /* XOR entre el crc actual y el polinómio generador */
   *crc ^= polinomioGenerador;
  }
 }
}
Para probar esta aplicación desde línea de comandos, se llama al ejecutable pasándole como único argumento la ruta del fichero.

Ej.: CRCx C:\TEMP\vacaciones.jpg

El resultado será la visualización por consola de todos los bytes que componen el fichero, el número de bytes tratados y el CRC calculado.

Como veis la cosa no es tan trivial como se planteo en la entrega anterior, pero si nos vale para entender como se hace en el mundo real.

Podéis contrastar el resultado obtenido aquí y que además contiene abundante información del tema que nos ocupa a un nivel mucho más profundo.

Os dejo el código fuente y el ejecutable para el que no tenga ganas de teclear ni compilar:


En la próxima y última entrega de esta saga veremos como proteger nuestro código de depuradores usando para ello nuestra estrella, el CRC.

sábado, 6 de marzo de 2010

El día que un CRC cambió mi vida parte II

El fundamento matemático del CRC nos habla de códigos de bloques lineales expresados como polinomios en cuerpos de Galois, pero si profundizamos por este camino nos podría dar una hemorragia cerebral.

En vez de eso, comenzaremos por dar un ejemplo sencillo, pasando de lo particular a lo general.

Imaginemos que nuestro mejor amigo nos manda el mensaje “SOS” por cualquier medio, indicándonos que se encuentra en peligro. Pero por desgracia durante la transmisión del mensaje ha habido interferencias electromagnéticas que han alterado el contenido del mensaje y lo que recibimos es “OSO”. 
No solamente no prestamos ayuda a nuestro amigo, sino que además nos cabreamos con él por llamarnos OSO.

Para evitar lo anterior y asegurarnos que el mensaje que nos llega está inalterado, nuestro amigo le aplicará un CRC, es decir, le añadirá al mensaje otro símbolo (de ahí viene lo de redundancia) que nos indicará si el mensaje ha sido alterado o no.

Ese símbolo extra no es más que el resto de dividir el mensaje por un valor previamente pactado en ambas partes.

Veamos el proceso:

Según el estándar ASCII el mensaje “SOS” se codifica como:

‘S’ es codificado con el valor 83.
‘O’ es codificado con el valor 79.

El mensaje sería 837983 y lo vamos a dividir por el símbolo ‘P’ que en ASCII es 80, el resto de esta división se concatena al mensaje origen:

837983 MOD 80 = 63

63 equivale a el símbolo ‘?’, por lo tanto el mensaje listo para enviar sería “SOS?”. 
Cuando recibamos el mensaje, como pactamos el CRC con nuestro amigo, repetimos el proceso y comprobamos si coincide.
Si el mensaje recibido hubiese sido “OSO?”, calcularíamos el CRC de “OSO”:

798379 MOD 80 = 59

59 equivale al símbolo ‘;’ que es distinto de ‘?’, luego ya estamos en condiciones de advertir que el mensaje no es fiable.

Para que los dispositivos electrónicos operen justamente como nosotros acabamos de hacer, los matemáticos, esos grandes inventores de realidades, idearon una manera magistral de entender y analizar los códigos cíclicos mediante polinomios.

Un patrón de 0 y 1 se representa como un polinomio con coeficientes de valor 0 y 1.

La potencia de cada término del polinomio muestra la posición del bit y el coeficiente el valor del bit.

Por ejemplo, el polinomio:



se representa como 10000010000010001. 

Como se observa el beneficio es inmediato ya que un patrón de 17 bits se representa con un polinomio de 4 términos.

Sin embargo hay que recalcar que la elección del divisor, llamado polinomio generador, no es trivial, pero nuevamente nuestros amigos matemáticos han elaborado algunos polinomios generadores estandarizados y que se aproximan al 100% de la detección del error en mensajes grandes.
Alguno de estos son:    
  • CRC-12.
  • CRC-16.
  • CRC-CCITT.
  • CRC-32.
Puede veniros bien profundizar en el cálculo del resto de una divisón de polinomios mediante operaciones lógicas XOR para entender luego el código que publicaré en sucesivas entregas. 


Aconsejo visitar:
Como veis la teoría es fácil, pero en la práctica, un fichero se compone de millones de bits y calcular el resto de una división de tal calibre es impensable.

En lugar de esto lo que se suele hacer es una mezcla de checksum con CRC, pero esto lo veremos en la próxima entrega, donde nos meteremos de lleno con un código que calcula el CRC de un fichero.

El día que un CRC cambió mi vida

Tal día como hoy, traceando el código desensamblado de una aplicación, me encontré, con sorpresa, un ingenioso método de técnica anti-depuración. El creador de la aplicación comprobaba la integridad de una parte de su código mediante un algoritmo CRC, algo que no se me abría ocurrido en la vida.
Debido a este hallazgo me puse a repasar los libros de la carrera en donde nos explicaban la técnica del CRC, pero con asombro vi que una cosa es la teoría y otra muy diferente es la práctica.
Pues bien, con este y otros artículos próximos quiero hacer que el CRC sea lo más entendible posible, ya que en la red hay infinidad de artículos, pero que se aproximen de los general a lo particular no hay tantos.
Comencemos entonces.
¿Qué es CRC?
CRC es el acrónimo de Código de Redundancia Cíclica o en inglés Cyclic Redundancy Check y es una técnica que se utiliza para comprobar si un flujo binario ha sufrido alguna modificación en el paso de un origen a un destino.
Algunos pensaran ¿flujo qué…?, ¿paso qué…?, vale, vale, un poco más despacio.
Todos sabemos que nuestro mundo está rodeado de dispositivos electrónicos y en donde la información generalmente se codifica con señales electromagnéticas, que habitualmente suelen ser ceros y unos lógicos a los que llamamos bits.
El traspaso de un punto a otro de estos bits es lo que se denomina flujo. Como algunos ejemplos cotidianos podríamos destacar:
  • Descomprimir archivos. Paso de un fichero comprimido (origen) a uno sin comprimir (destino).
  • Ver fotos en nuestros dispositivos. Paso de un fichero binario (origen) a un programa (destino) que interprete esa foto y la visualice.
  • Intercambiar archivos con nuestros móviles por cualquier medio.
  • Mandar un correo.
  • Navegar por la web.
·     Y en general todo lo que implique traspaso de información de un punto a otro.
Ahora pensad ¿qué ocurriría si ese flujo fuese alterado? bien por problemas en el medio de transmisión (cable, ondas, luz, …) o bien intencionadamente por algún personajillo que le guste lo ajeno. Pues que sencillamente nadie podría garantizar la integridad de los datos recibidos y eso en determinados contextos puede ser fatal.
Y es aquí donde entran en juego técnicas como el CRC para comprobar la integridad de un mensaje o flujo de datos.
En la próxima entrega de la saga explicaré el fundamento que hace esto posible.

martes, 2 de marzo de 2010

Como un niño con juguete nuevo

Hace apenas unas horas me he matriculado en un curso semipresencial que no tiene desperdicio "Avances en seguridad en Internet".

Para empezar trata de temas que son mi auténtica pasión y para finalizar se realiza en Salamanca, una ciudad que emana cultura por todos sus rincones o como bien puntualiza mi hermana 'huele a libro'.

Sólo me queda decir a todos los que estudiáis conmigo que aun estáis a tiempo de matricularos ya que el plazo termina el 10 de Marzo y el curso promete.

El temario es:

1. Seguridad en la web, problemática, sistemas y políticas de seguridad (2 horas)

2. Fundamentos de la criptología: (3 horas)
  • Base teórica y fundamentos: criptografía y criptoanálisis

3. Tipos de sistemas criptográficos: (3 horas)
  • Criptosistemas de clave privada: IDEA, DES, TRIPLE DES, AES
  • Criptosistemas de clave pública: RSA, Diffie-Hellman
  • Protocolo SSL

4. Aplicaciones Seguras: (3 horas)
  • Autenticación, Firmas digitales.
  • Funciones resumen: MD5, DSA.
  • Trusted Third Parties.
  • Certificados X.509, Correo electrónico seguro. PGP.
  • Medios de Pago: SSL, SET.
  • Dinero electrónico. Banca electrónica.

5. Técnicas de ataque: (3 horas)
  • Herramientas de recogida de información, Herramientas de búsqueda de debilidades.

6. Técnica de Spoofing: (3 horas)
  • Técnica de sniffer, troyanos, firewalls

7. Auditoría Informática (3 horas)
8. Certificación Profesional (3 horas)
9. Legislación Vigente (2 horas)
10. e-Forensis (2 horas)
11. Programación de Exploits (2 horas)
12. Análisis de ficheros binarios (1 horas)

martes, 23 de febrero de 2010

Práctica de Programación III de ITIS por la UNED curso 2008/09

Práctica que realicé de la asignatura de Programación III cursada en el año 2008/09.
Asignatura durísima al igual que su práctica, pero que a mi modo de ver es de las más importantes de la carrera.

Se empiezan a ver algoritmos realmente prácticos y efectivos en resolución de problemas.

En esta práctica se nos pedía resolver sikakus, algo que por aquellos días me sonaba a 'chino' y que después de terminarla fue para mí como el abecedario.

Como siempre, todo aquel que quiera el código fuente ya sabe donde pedirlo.


Descargar Memoria práctica

sábado, 20 de febrero de 2010

Estoy en la nube

Desde hace relativamente poco tiempo y desde mi última visita al Simo Network del 2009, aparece un nuevo vocablo en mi jerga informática que no deja de perseguirme, “la nube”.

Muchos de vosotros ya tenéis claro este concepto, pero seguro que para otros es completamente nuevo. Pues bien para ello es mi reflexión.
Este concepto será el futuro inmediato de todo lo que nos rodea a nivel informático, tanto a usuarios, como a profesionales, y sin olvidarnos de las empresas.
Podemos decir que “informática en la nube” o "cloud computing" es la conexión de todos los recursos que se disponen en la red sin ningún tipo de restricción sobre la máquina en donde nos encontremos.
Es decir, tan solo nos bastará con disponer de un terminal con una capacidad de procesamiento y almacenamiento relativamente pequeña para poder realizar todas nuestras tareas cotidianas, como por ejemplo, crear documentos, hojas de cálculo, desarrollo de software, creación, edición y visionados multimedia como música, imagen y vídeo…y todo lo que se nos ocurra.
Seguro estoy que la mayoría de vosotros ya usáis este concepto sin saberlo. ¿Qué no me crees?, entonces dime que son servicios como iCloud, eyOS, Windows Azure, Dropbox, Filebox, skyDrive, Gmail, iTunes, Spotyfi, Google maps, Google street, Google Earth, Google SketchUp, Google Picasa, .... y así podríamos continuar hasta acabar en el infinito y mas allá.
Todo esto plantea muchas ventajas y a la vez muchas dudas.
Las ventajas son evidentes, simplemente si nos hace falta un servicio y ya está en la nube, haremos uso de él sin preocuparnos por instalaciones, almacenamiento, capacidad de procesamiento y mucho menos del mantenimiento.
Las desventajas, también son evidentes, ¿Qué ocurre con nuestros datos?, ¿Estarán seguros de terceras personas?...
Una de las personas más importantes de este siglo  Richard Stallman asegura que la nube pone en peligro las libertades de los usuarios.
Como podéis observar la polémica está servida.
Por mi parte yo sí que haré uso de ella, siempre y cuando lo necesite. Véase como ejemplo mi descubrimiento de Dropbox (gracias kiko) o filebox, que me permite subir copias de respaldo de mis datos digitales de manera tal, que me despreocupa de posibles borrados accidentales o cosas similares debidos a mi integral despiste. Imagínate que pasaría si se te estropea el disco duro que alberga todas tus fotos, documentos o programas más importantes.
Todo lo anterior ha sido dando una visión superficial a nivel de usuario, imaginaros si nos adentramos a los que nos compete la creación de software, pero eso por el momento lo pospongo.
Para terminar, si os ha picado la curiosidad os invito a que hagáis uso de la nube y visitéis la definición en Wikipedia que no tiene desperdicio.
Saludos y hasta mi próxima reflexión.