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)