GMT-4

Internacionalización en PHP usando gettext

2008-09-07T12:45:00.006-04:00

En algunas oportunidades se hace necesario que nuestro sitio web tenga versiones en múltiples idiomas.

El concepto de internacionalización o i18n en sitios web consiste no sólo en mostrar los contenidos en el idioma del usuario, sino que también implica ajustarse a sus configuraciones regionales tal como: formatos de fechas, formatos de números y reglas de ordenamiento alfabético. En la actualidad la mayoría de las base de datos y lenguajes de programación modernos tienen soporte para i18n.

En este artículo me enfocaré en el problema de mostrar el contenido de un sitio web en múltiples idiomas, para ello les presentaré mi solución favorita basada en gettext, que es la biblioteca GNU para internacionalización. Los ejemplos que aquí daré están basados en PHP, pero son totalmente aplicables a otros lenguajes de programación como por ejemplo C.

Codificación
Como primera medida en el proceso de internacionalización, nuestros sistemas debieran ser desarrollados utilizando codificación UTF-8 en vez de la tradicional ISO-8859-1 también conocida como LATIN1.

La codificación UTF-8 prácticamente soporta la mayoría de los simbolos (y caracteres) de escritura a nivel mundial. La codificación LATIN1 es mucho más reducida en la cantidad de simbolos (o caracteres) de escritura, pero es suficiente en caso que queramos mantener nuestro sitio en español e inglés.

En caso que optemos por desarrollar un sistema con codificación LATIN1 o si tenemos que dar soporte multi-idioma a sistemas heredados que ya fueron desarrollados con LATIN1, se deberán realizar algunos pasos adicionales que iré comentando en los ejemplos.

Módulo gettext
Cuando generamos contenidos hacia el web, usualmente extraemos la información de dos fuentes: base de datos y textos estáticos.

La traducción del contenido de la base de datos se debe realizar caso a caso de acuerdo a las características de cada sistema y no es cuerto en este artículo.

La traducción de los textos estáticos se realizará usando gettext que usualmente ya está habilitada en sistemas LINUX. En Windows basta con editar el archivo de configuración de PHP y descomentar (o escribir) la siguiente linea:

extension=php_gettext.dll

Adicionalmente, para generar las traducciones es necesario tener instalado gettext, el cual normalmente ya viene instalado en LINUX y puede ser descargado para Windows en la página del proyecto GNU para Windows.

Manos a la obra
Usualmente en nuestro código tenemos instrucciones como las siguientes:

echo "Hola mundo";
print "Hola mundo";
printf("Hola %s", $nombre);

Todas esas instrucciones deberán ser modificadas para ser procesadas por la función gettext() o mejor aún por un alias de esa función llamado simplemente _(), con lo que tendremos los siguientes reemplazos:

echo _("Hola mundo");
print _("Hola mundo");
printf(_("Hola %s"), $nombre);

Esta función no realiza ningún cambio en los textos. Deberemos aplicar estos cambios a todo el contenido de nuestro sistema lo que va a implicar cambiar el estilo de programación, como por ejemplo en los siguientes ejemplos:

echo "Bienvenido $nombre";

echo "
<h1>Página principal</h1>
<p>Bienvenido $nombre</p>
";

hacemos uso de una de las características más amigables de PHP que consiste en incrustar variables directamente en un string. Para trabajar con gettext, deberemos reescribir este trozo de código. Como recomendación, les suguiero utilizar las funciones printf() y sprintf():

printf(_("Bienvenido %s"), $nombre);

printf("<h1>%s</h1><p>%s $nombre</p>",
_("Página principal"), _("Bienvenido"));

Generar traducciones
Una vez que se hayan intervenido todos los textos del sistema, se deberá ejecutar un programa que escanea todo el código fuente buscando las intervenciones que realizamos, esto crea un archivo de traducciones donde se consolidan todos los textos encontrados, dicho archivo de texto deberá ser traducido (existen programas que ayudan a hacerlo) y luego se generará un archivo binario que contiene todas las traducciones.

El primer paso es escanear todos los archivos involcados, por ejemplo para buscar todos los archivos con extensión .php y .inc se ejecuta el siguiente comando:

find . -name \*.php -o -name \*.inc > messages.txt

A continuación realizamos el proceso de escaneo de textos a traducir mediante el comando xgettext:

xgettext --language=PHP --from-code=ISO-8859-1 -o messages.po -f messages.txt

Por defecto, este comando trabaja en UTF-8, por lo que si nuestro código está en LATIN1 (ISO-8859-1) debemos utilizar el parámetro --from-code=ISO-8859-1.

La salida de este comando nos generará un archivo de texto que deberá ser traducido, por ejemplo al inglés. La edición puede ser realizada manualmente o por medio de algún programa como por ejemplo Poedit.

Una vez que tengamos nuestro archivo de traducción, deberemos convertirlo (compilarlo) a formato .mo mediante el comando msgfmt:

msgfmt messages.po -o messages.mo

Y con esto ya hemos generado nuestro archivo de traducción. Eventualmente podemos generar muchos archivos de idiomas. Ahora sólo nos falta decirle a PHP que reconozca estos archivos de idioma.

Habilitar traducciones
Debemos hacerle saber al sistem dónde encontrar nuestro archivo .mo. Los sistemas operativos tienen directorios predefinidos para estos fines, sin embargo, para evitar problemas de permisos y privilegios, prefiero configurar el sistema para indicarle manualmente dónde buscarlos.

Como en este ejemplo hemos traducido los textos al idioma inglés, pondremos el archivo de traducción en la siguiente ubicación:

/tmp/locale/en_US/LC_MESSAGES/messages.mo

Para habilitar la traducción de los textos utilizaremos el siguiente código donde la variable $locale define el idioma que será utilizado que en este caso será en_US:

$locale = 'en_US';
if (!defined('LC_MESSAGES')) define('LC_MESSAGES', 6);
setlocale(LC_MESSAGES, $locale);
bindtextdomain('facturanet', '/tmp/locale');
textdomain('messages');

En caso de que $locale indique un idioma no definido, el sistema mostrará los textos en su idioma original. Por supuesto que deberás cambiar el directorio /tmp/locale por uno más apropiado.

Los archivos binarios .mo son guardados en cache, por lo que luego de actualizar el archivo se recomienda reiniciar el servidor web.

Selección de idioma
Debido a que la variable $locale es la que determina el idioma que se presentará al usuario, les recomiendo que sea una variable de sesión de manera que el sistema recuerde el idioma del usuario entre cada página. Se debería crear una página PHP en que el usuario pueda cambiar de idioma.

Para mejorar la experiencia del usuario, es posible autodetectar el idioma del usuario consultando la variable del servidor $_SERVER['HTTP_ACCEPT_LANGUAGE'].

Otras características
Hay otras características que no alcanzaré a revisar ahora y que permiten un mejor trabajo con la boblioteca gettext:

En caso de que modifiquemos nuestro sistema y tengamos que realizar nuevas traducciones, no es necesario repetir todo el proceso, gettext provee comandos para incorporar nuevas palabras a un archivo ya existente mediante msgmerge.
Además de la función _() existe otras funciones gettext para realizar traducciones más complejas, como por ejemplo diferenciación de singuales y plurales.

El performance de Google App Engine

2008-06-19T00:24:00.000-04:00

Hace unos días estuve probando la nueva plataforma Google App Engine la cual permite hostear en los servidores de Google aplicaciones WEB desarrolladas en Python.

El modelo de negocio de Google es similar al ofrecido por Amazon, en el cual se cobra de acuerdo al tráfico, almacenamiento de datos y tiempo de CPU efectivamente utilizados. Sin embargo, Google va más allá (o provee un servicio más acotado, según el punto de vista) al proveer de una plataforma de desarrollo basada en Python.

Además de la estabilidad y disponibidad de las aplicaciones desarrolladas sobre Google App Engine, uno de las características importantes es la escalabilidad de su plataforma.

Construí una aplicación básica que hace un par de consultas a la base de datos y que genera un documento HTML de aproximadamente 1KB de información. Luego, con la herramienta Apache Benchmark (ab) realicé pruebas de carga utilizando un enlace a Internet dedicado. La prueba consistió en cargar dicha página de manera concurrente durante 5 segundos. En cada prueba modifiqué el nivel de concurrencia desde 1 hasta 100 requests en paralelo.

En promedio el tiempo de carga de la página completa demoraba 500 milisegundos, lo cual es bastante tiempo para una página liviana y que no hace más de 10 consultas SQL. Sin embargo, las pruebas de concurrencia me dejaron impresionado ya que el nivel de servicio prácticamente no se vió afectado aunque haya aumentado a 100 conexiones en paralelo, tal como lo muestro en el siguiente gráfico.

Sin concurrencia se alcanzó un nivel de 2.33 requests por segundo, al utilizar una concurrencia de 10 conexiones simultaneas se logró un nivel de 23.98 requests por segundo, finalmente, al alcanzar un nivel de 100 conexiones simultaneas se logró un nivel del 192.38 requests por segundo, es decir el servicio proveyó de un escalamiento lineal prácticamente de 1:1. Hasta ahora, disponer de enlace y hardware capaces de brindar dicho nivel de escalabilidad era extremadamente caro.

Sin duda, este nuevo producto de Google será un gran producto para los desarrolladores de software, brindando un gran nivel de escalabilidad a un costo bastante bajo.

Cool-php-captcha

2008-06-11T23:18:00.002-04:00

En vista que había dedicado varias horas a implementar un sistema de captcha, aproveché de invertir un par de horas más y crear un proyecto que llamé cool-php-captcha publicado en Google Code bajo licencia GPLv3.

Los invito a visitar la página del proyecto http://code.google.com/p/cool-php-captcha y darme sus opiniones.

Crear un CAPTCHA como el de Google

2008-06-02T01:32:00.003-04:00

Esta es la segunda parte de mi artículo sobre la creación de CAPTCHAS. En el artículo anterior vimos el procedimiento para crear un CAPTCHA básico al cual le agregamos algunas mejoras para aumentar su complejidad y así disminuir su vulnerabilidad.

En esta segunda parte vamos a realizar algunas mejoras en la generación de imágenes, incorporaremos nuevas tipografías (la mayoría son OpenSource o Freeware) y optimizaremos el código.

Con estos cambios obtendremos un CAPTCHA de muy buena calidad sin recurrir al uso de "artefactos" o imágenes de fondo que conviertan el CAPTCHA en algo horrible, como los siguientes que son utilizados por algunos de los grandes sitios de internet: Delicious, Facebook, Fotolog, Live Journal y Microsoft Live:

Más bien, el resultado final que vamos a obtener va a ser un CAPTCHA muy parecido a los generados por Google:
Si bien este tipo de imagen no es de las más seguros, es bastante mejor que la mayoría de los captchas que están disponibles en la red.

Texto a utilizar en el CAPTCHA
En el ejemplo del artículo anterior utilizabamos un generador de textos aleatorios que intercalaba vocales y consonantes con el fin de generar palabras medianamente pronunciables.

En esta versión final inicialmente desarrollé una mejora de dicha función ya que la original ponía las vocales siempre en las mismas posiciones lo cual hacía más fácil la decodificación del captcha.

Esta nueva función genera textos aleatorios alternando consonantes y vocales al azar:

function getCaptchaText() {
$length = rand(5,7);
$consonants = "abcdefghijlmnopqrstvwyz";
$vocals = "aeiou";
$text = "";
$vocal = rand(0,1);
for ($i=0; $i<$length; $i++) {
if ($vocal) {
  $text .= substr($vocals, mt_rand(0, 4), 1);
} else {
  $text .= substr($consonants, mt_rand(0, 22), 1);
}
$vocal = !$vocal;
}
return $text;
}

Palabras de diccionario
Sin embargo, al realizar algunas pruebas me dí cuenta que al utilizar palabras de diccionario disminuye considerablemente el tiempo de ingreso y la tasa de error de usuarios. Además, el hecho de utilizar palabras "conocidas por el usuario" permite generar caracteres con mayor deformación.

Para la generación de palabras de diccionario, descargué un archivo de palabras en español (también puede ser en inglés u otro idioma según el público objetivo) desde http://www.word-list.com. Solamente mantuve las palabras entre 5 y 7 caracteres de longitud lo cual me dejó con solo 20.645 palabras diferentes.

No debemos olvidar quitar del diccionario palabras que podrían ser ofensivas para nuestros usuarios como por ejemplo: "zorra", "tonto", "mierda", "violador", "suicida" o "asesino".

En principio, para escoger la palabra de diccionario a utilizar, se debiera escoger un número al azar y luego recorrer el archivo de palabras línea por línea mediante fgets() hasta llegar a la línea buscada. Dicho procesamiento es altamente ineficiente por lo que hice algunos ajustes para hacer uso de fseek(): Cada una de las lineas del archivo de palabras las rellené con espacios en blanco hasta totalizar 7 caracteres más el caracter de salto de linea (\n), con lo cual quedan 8 bytes por cada palabra. Por lo tanto, si quisiera obtener la palabra de la posición 388, se debería hacer fseek(387*8) para luego leer la linea fgets().

function getDictionaryCaptchaText() {
   $fp = fopen("words-es.txt", "r");
   $linea = rand(0, (filesize("words-es.txt")/8)-1);
   fseek($fp, 8*$linea);
   $text = trim(fgets($fp));
   fclose($fp);
   return $text;
}

La desventaja de utilizar textos de diccionario es que el universo de palabras a utilizar disminuye de millones (entre 2 y 40 millones al utilizar hasta 7 caracteres) a miles (20 mil al utilizar palabras entre 5 y 7 caracteres).

Como una opción para solucionar este problema introduje una modificación que cambia al azar algunas de las vocales de una palabra, por ejemplo la palabra "caviar" puede cambiar a "cuvier", "covoar", "cavour", etc.


function getDictionaryCaptchaText($extended = true) {
   $fp = fopen("words-es.txt", "r");
   $linea = rand(0, (filesize("words-es.txt")/8)-1);
   fseek($fp, 8*$linea);
   $text = trim(fgets($fp));
   fclose($fp);


   // Cambio vocales al azar
   if ($extended) {
       $text = str_split($text, 1);
       $vocals = array('a','e','i','o','u');
       foreach ($text as $i => $char) {
           if (mt_rand(0,1) && in_array($char, $vocals)) {
               $text[$i] = $vocals[mt_rand(0,4)];
           }
       }
       $text = implode('', $text);
   }
   return $text;
}

Como opción personal voy a utilizar simplemente las palabras de diccionario. Además, como mejora podría modificarse el script para que utilice como diccionario palabras en el idioma del usuario. Esto se puede realizar determinando el país del usuario de acuerdo a su dirección IP o mediante el parámetro HTTP HTTP_ACCEPT_LANGUAGE el cual indica el idioma de preferencia del usuario.

Generación de la imagen
En la generación de la imagen se van a aplicar las siguientes transformaciones:

Disminuir el espaciado entre caracteres, incluso traslapando algunos caracteres.
Variación de tamaños de caracteres.
Diversidad de tipografías (pero utilizando una sola tipografía por cada imágen).
Alternación de color de textos.
Ondulación del texto en los ejes X e Y.

1. Disminuir el espaciado entre caracteres
Las tipografías están construidas para mantener una sepación específica entre cada caracter para aumentar la legibilidad. Sin embargo, esto es precisamente lo que no se debe hacer al generar un captcha. Al juntar los caracteres y permitir su traslape se dificulta el proceso de separación caractar a caracter, esto es muy importante porque la extracción de cada uno de los caracteres es uno de los pasos escenciales en el proceso de decodificación de captchas.

En las siguientes imagenes vemos cómo el texto de la derecha tiene sus caracteres muy juntos.
Para lograr disminuir el espaciado entre cada caracter tuve que imprimir en la imagen caracter por caracter con el siguiente código:

// Texto a imprimir
$text = getDictionaryCaptchaText($extended);
// Definiciones de latipografía a utilizar
// - font: archivo TTF
// - condensation: Cantidad de pixeles que se quitará entre cada caracter
$fontcfg = $fonts[mt_rand(0, sizeof($fonts)-1)];
$fontsize = 32;
$x = 20;
for ($i=0; $i<=6; $i++) {
   $coords = imagettftext($im, $fontsize, 0,
           $x, 47, $fg_color, 'fonts/'.$fontcfg['font'], substr($text, $i, 1));
   $x += ($coords[2]-$x)-$fontcfg['condensation'];
}

2. Variación de tamaños de caracteres
La primera alteración a realizar es el cambio del tamaño de cada caracter como se muestra a continuación:

// Texto a imprimir
$text = getDictionaryCaptchaText($extended);

// Definiciones de latipografía a utilizar
// - font: archivo TTF
// - minSize: tamaño de fuente mínimo a utilizar
// - maxSize: tamaño de fuente máximo a utilizar
// - condensation: Cantidad de pixeles que se quitará entre cada caracter
$fontcfg = $fonts[mt_rand(0, sizeof($fonts)-1)];

$x = 20;
for ($i=0; $i<=6; $i++) {
   $coords = imagettftext($im, rand($fontcfg['minSize'],$fontcfg['maxSize']), 0,
           $x, 47, $fg_color, 'fonts/'.$fontcfg['font'], substr($text, $i, 1));
   $x += ($coords[2]-$x)-$fontcfg['condensation'];
}

3. Diversidad de tipografías
Escogí un conjunto de tipografías que alterno entre cada generación. En principio quise alternar la tipografía al generar cada caracter, pero el resultado no era muy vistoso, por lo tanto ahora utilizo la misma tipografía para todos los caracteres:

No debemos olvidar que la mayoría de las tipografías que están instaladas en nuestros computadores están protegidas por copyright, por lo que buscando en internet descargué varias tipografías OpenSource o Freeware desde el sitio http://www.urbanfonts.com. Con un poco de paciencia se pueden encontrar tipografías que permiten generar captchas más originales:

4. Alternación de color de textos
Principalmente por un tema estético introduje alternación entre 3 colores posibles para el captcha. Algunos podrían tentarse de poner cada caracter en diferente color, pero esto sería un error porque facilitaría al decodificador separar cada caracter.

Para definir el color, defino un arreglo con los colores RGB y luego obtengo el color escogido al azar:


$colors = array(
 array(27,78,181), // azul
 array(22,163,35), // verde
 array(214,36,7),  // rojo
);

$color = $colors[mt_rand(0, sizeof($colors)-1)];
$fg_color = imagecolorallocate($im, $color[0], $color[1], $color[2]);

5. Ondulación del texto en los ejes X e Y Finalmente aplicamos una transformación al texto para en base a una función senoidal. Esto lo hacemos en el eje X e Y. Como una imágen vale más que mil palabras, en el siguiente ejemplo muestro el proceso de transformación: se comienza con una imagen plana (en color rojo) a la cual le aplico un filtro "wave" en el eje X (color verde) y en el eje Y (color azul). Una vez que apliquemos este filtro en ambos ejes obtenemos como resultado la imagen de la derecha (en color verde):

La generación de ondulación se realiza mediante la función imagecopy() que va desplazando linea por linea la imagen de acuerdo a una función senoidal. Esto se realiza en el eje X y luego en el eje Y. Se define una variable aleaoria $k para definir la "fase" o ángulo inicial de la ondulación. La forma de la onda senoidal se define por la amplitud (valor mas alto y bajo de la onda) y el período que define la "frecuencia":


// Genero ondas verticales (eje X)
$period    = $scale*$periodoX;
$amplitude = $scale*$amplitudX;
$k         = rand(0,100);
for ($i = 0;$i < ($width*$scale);$i++) {
 imagecopy($im,$im,
           $i-1, sin($k+$i/$period) * $amplitude,
           $i,0,
           1,$height*$scale);
}

// Genero ondas horizontales (eje Y)
$period    = $scale*$periodoY;
$amplitude = $scale*$amplitudY;
$k         = rand(0,100);
for ($i = 0;$i < ($height*$scale);$i++) {
   imagecopy($im,$im,
           sin($k+$i/$period) * $amplitude, $i-1,
           0,$i,
          $width*$scale,1);
}

Juntando las piezas

Una vez que se junten todos estos pasos y parametrizando algunas cosas obtenemos el siguiente resultado:

Como se pueden dar cuenta -por pura coincidencia- se generaron varias palabras potencialmente ofensivas que idealmente no debieran presentarse al usuario.

El programa final es el siguiente:
(recuerda descargar los archivos de tipografía desde algún sitio como por ejemplo http://www.urbanfonts.com)

<?php
/**
* Script para la generación de CAPTCHAS
*
* Autor: José Rodríguez jose.rodriguez at exec.cl
* http://joserodriguez.cl
* http://www.exec.cl
*
* En caso que hagas uso de este código o una variación,
* te pido que me lo hagas saber.
*
* Esta obra está licenciada bajo Creative Commons
* Reconocimiento - No comercial - Compartir bajo la misma licencia 3.0 Unported License.
* http://creativecommons.org/licenses/by-nc-sa/3.0/
*
*/



// Alto y ancho de la imagen
$width  = 200;
$height = 66;

// Nombre de la variable de sesion
$session_var = "captcha";

// Colores
$colors = array(
   array(27,78,181), // azul
   array(22,163,35), // verde
   array(214,36,7),  // rojo
);

/**
* Configuración de tipografías
* - font: archivo TTF
* - condensation: cantidad de pixeles que se juntará cada caracter
* - minSize: tamaño minimo del texto
* - maxSize: tamaño máximo del texto
*/
$fonts = array(
   array('font' => 'Danoisemedium.ttf','condensation' => 2,   'minSize' => 28, 'maxSize' => 40),
   array('font' => 'HEINEKEN.TTF',     'condensation' => 2.5, 'minSize' => 24, 'maxSize' => 40),
   array('font' => 'VeraSeBd.ttf',     'condensation' => 3.5, 'minSize' => 20, 'maxSize' => 33),
   array('font' => 'VeraSe.ttf',       'condensation' => 4,   'minSize' => 26, 'maxSize' => 40),
   array('font' => 'CrazyHarold.ttf',  'condensation' => 2,   'minSize' => 20, 'maxSize' => 28),
   array('font' => 'Duality.ttf',      'condensation' => 2,   'minSize' => 28, 'maxSize' => 48),
   /*
   // Otras tipografías
   array('font' => 'BeyondWonderland.ttf', 'condensation' => 3, 'minSize' => 28, 'maxSize' => 39),
   array('font' => 'BennyBlanco.ttf',      'condensation' => 1, 'minSize' => 24, 'maxSize' => 30),
   array('font' => 'freak.ttf',            'condensation' => 2, 'minSize' => 32, 'maxSize' => 54),
   */
);

// Configuración de ondulacion del texto
// Periodo y amplitud en ejes X e Y
$periodoY  = 15;
$amplitudY = 16;
$periodoX  = 12;
$amplitudX = 4;

/**
* Factor de resolución con que se trabajará internamente
* Se prefiere manipular la imagen al doble de su tamaño
* para evitar pérdida de calidad al aplicar filtro wave.
* Valores posibles: 1, 2 o 3.
*/
$scale = 2;

// Utilizar palabras inexistentes?
$extended = false;


// Permite habilitar depurado
$debug = false;
$ini = microtime(true);












session_start();



// Creo la imagen
$im = imagecreatetruecolor($width*$scale, $height*$scale);
$bg_color = imagecolorallocate($im, 255, 255, 255);
$color = $colors[mt_rand(0, sizeof($colors)-1)];
$fg_color = imagecolorallocate($im, $color[0], $color[1], $color[2]);
imagefilledrectangle($im, 0, 0, $width*$scale, $height*$scale, $bg_color);




// Genero el texto, caracter por caracter
$text = getDictionaryCaptchaText($extended);
$fontcfg = $fonts[mt_rand(0, sizeof($fonts)-1)];
$x = 20*$scale;
for ($i=0; $i<=6; $i++) {
  $coords = imagettftext($im, rand($fontcfg['minSize'],$fontcfg['maxSize'])*$scale, 0,
             $x, 47*$scale, $fg_color, 'fonts/'.$fontcfg['font'], substr($text, $i, 1));
  $x += ($coords[2]-$x)-$fontcfg['condensation']*$scale;
}




// Genero ondas verticales (eje X)
$period    = $scale*$periodoX;
$amplitude = $scale*$amplitudX;
$k         = rand(0,100);
for ($i = 0;$i < ($width*$scale);$i++) {
   imagecopy($im,$im,
             $i-1, sin($k+$i/$period) * $amplitude,
             $i,0,
             1,$height*$scale);
}

// Genero ondas horizontales (eje Y)
$period    = $scale*$periodoY;
$amplitude = $scale*$amplitudY;
$k         = rand(0,100);
for ($i = 0;$i < ($height*$scale);$i++) {
   imagecopy($im,$im,
             sin($k+$i/$period) * $amplitude, $i-1,
             0,$i,
             $width*$scale,1);
}




// Reduzco el tamaño de la imagen
$imResampled = imagecreatetruecolor($width, $height);
imagecopyresampled ($imResampled,$im,0,0,0,0,$width, $height,$width*$scale,$height*$scale);
imagedestroy($im);


// Guardo el texto en sesión
$_SESSION[$session_var] = $text;


if ($debug) {
   imagestring($imResampled, 1, 1, $height-8, "$text k:$k ".$fontcfg['font'].' '.round((microtime(true)-$ini)*1000), $fg_color);
}


header("Content-type: image/jpeg");
imagejpeg($imResampled, null, 80);

// Limpieza
imagedestroy($imResampled);





/**
* Retorna un texto de diccionario aleatorio
*/
function getDictionaryCaptchaText($extended = false) {
   $fp = fopen("words-es.txt", "r");
   $linea = rand(0, (filesize("words-es.txt")/8)-1);
   fseek($fp, 8*$linea);
   $text = trim(fgets($fp));
   fclose($fp);


   // Cambio vocales al azar
   if ($extended) {
       $text = str_split($text, 1);
       $vocals = array('a','e','i','o','u');
       foreach ($text as $i => $char) {
           if (mt_rand(0,1) && in_array($char, $vocals)) {
               $text[$i] = $vocals[mt_rand(0,4)];
           }
       }
       $text = implode('', $text);
   }

   return $text;
}







/**
* Retorna un texto aleatorio
*/
function getCaptchaText() {
   $length = rand(5,7);
   $consonants = "abcdefghijlmnopqrstvwyz";
   $vocals = "aeiou";
   $text = "";
   $vocal = rand(0,1);
   for ($i=0; $i<$length; $i++) {
       if ($vocal) {
           $text .= substr($vocals, mt_rand(0, 4),  1);
       } else {
           $text .= substr($consonants, mt_rand(0, 22), 1);
       }
       $vocal = !$vocal;
   }
   return $text;
}



?>

Creación de un CAPTCHA (o test de turing)

2008-05-28T00:15:00.008-04:00

A esta altura, la mayoría de nosotros nos hemos encontrado en situaciones que cuando ingresamos información en un formulario para registrarnos en algún servicio -como por ejemplo crear una casilla de correo o descargar un archivo de servicios como rapidshare- el sitio nos pide que escribamos el texto de una imagen que vemos en pantalla.

Estos mecanismos de validación permiten -en teoría- distinguir entre humanos y computadores, y así prevenir abusos como por ejemplo la publicación de spams en los comentarios de blogs y la creación masiva de casillas de correo para spamming.

En los últimos años han proliferado diversos mecanismos de CAPTCHA (Completely Automated Public Turing test to tell Computers and Humans Apart), como por ejemplo resolver un problema matemático, indicar el animal que ves es una fotografía o -el más popular- identificar el texto que ves en una imágen.

Una de las desventajas de los CAPTCHAs es que tienen serias deficiencias de accesibilidad. Además existen algunos casos extremadamente molestos para el usuario como el siguiente ejemplo utilizado en Rapidshare:

Debido a que la mayoria de los desarrollos de software en que he participado son sistemas cerrados o que no son un potencial blanco de ataques de spamming, no me he visto en la necesidad de implementar mecanismos de CAPTCHA, sin embargo, haciendo algunos experimentos he llegado a implementar un sistema sencillo en PHP que les describo a continuación.

Implementación de CAPTCHA en PHP
En este ejercicio voy a generar un CAPTCHA que le presente al usuario una imagen con letras que el usuario deberá escribir en un formulario. Debido al uso de imágenes, me apoyaré en la biblioteca GD, por lo que para estos ejemplos PHP debe tener soporte para GD.

Mi objetivo es generar un captcha que nos brinde un nivel de seguridad mínima y en ningún caso desarrollar un sistema infalible. Detrás de la generación (y decodificación) de los captchas existen teorías de procesamiento de imágenes y reconocimiento de caracteres que no son parte de este artículo.

El modelo general consiste en construir un script PHP que retorne una imagen con un texto aleatorio. El texto original será almacenado en una variable de sesión. Al procesar el formulario se deberá comparar el texto ingresado por el usuario con el texto almacenado en la variable de sesión.

Versión 1
Mi primera versión consiste en una implementación básica sólo para desarrollar la funcionalidad mínima del sistema:

<?php

// Alto y ancho de la imagen
$width  = 250;
$height = 60;
// Tipografia
$font = "arial.ttf";
// Nombre de la variable de sesion
$session_var = "captcha";




// Genero la imagen
$im = imagecreatetruecolor($width, $height);
$bg_color = imagecolorallocate($im, 255, 255, 255);
$fg_color = imagecolorallocate($im, 0, 0, 0);
imagefilledrectangle($im, 0, 0, $width, $height, $bg_color);

// Genero el texto
$text = "secret";
imagettftext($im, 20, 0, 11, 21, $fg_color, $font, $text);

// Guardo el texto en sesión
session_start();
$_SESSION[$session_var] = $text;


// Genero la imagen
header("Content-type: image/png");
imagepng($im);

// Limpieza
imagedestroy($im);

?>

Este script genera una imagen de 250x60 pixeles, con color de fondo blango y texto arial negro. El texto utilizado en la imagen se guarda en la variable de sesión captcha. El resultado de este script es la siguiente imagen:

En el script que procesa el formulario, basta comparar el valor de $_SESSION['captcha'] con el texto ingresado en el formulario para confirmar que el captcha haya sido ingresado satisfactoriamente. Para reducir la tasa de error, es posible quitar los eventuales espacios en blanco y convertir el texto a minúculas para hacer una comparación case-insensitive.

Ahora que contamos con el código base podemos continuar mejorando nuestro script.

Versión 2
Las mejoras que introduciremos en esta versión son las siguientes:

Generación de un texto aleatorio.
Generar texto con distintas tipografías.
Agregar transformaciones simples al texto.
Aumentar el tamaño y darle un color más amigable.

La generación de un texto aleatorio puede ser algo tan sencillo como extraer los primeros 6 caracteres de un valor MD5 como el siguiente: substr(md5(uniqid(),0,6) el cual genera un string con números y letras entre la "a" y la "f".

Sin embargo construiremos algo más elaborado donde podamos controlar los caracteres a generar e intentaremos que el texto sea medianamente pronunciable con el fin de ser más amigable con el usuario. Una manera simple de generar texto pronunciable es asegurándonos de tener suficientes vocales y quitando algunas letras poco usadas en el español como la "x" y la "k". Definí arbitrariamente la longitud del texto a 6 caracteres lo cual minimiza la generación de palabras mal vistas como "pene", "puta" o "malo" y da una cantidad de combinaciones de letras apropiada.

Para ello elaboré una función que retorna textos aleatorios intercalando una consonante y una vocal:

<?php

function getCaptchaText($length = 6) {
$consonants = "bcdfghjlmnpqrstvwyz";
$vocals     = "aeiou";

$text = "";
$imax = $length/2;
for ($i=0; $i<$imax; $i++) {
    $text .= substr($consonants, mt_rand(0, 18), 1);
    $text .= substr($vocals,     mt_rand(0, 4),  1);
}
return substr($text, 0, $length);
}

?>

Por lo tanto, en el script original reemplazamos:

$text = "secret";

por:

$text = getCaptchaText(6);

Con este cambio ahora generamos captchas como los siguientes:

Para hacer el captcha más complejo vamos a generar el texto con distintas tipografías, agregarle rotación independiente a cada letra y juntar (o condensar) las letras para que se produzca un traslape que hará más dificil su decodificación.

Extraje algunos archivos .ttf desde mi directorio C:\WINDOWS\Fonts y luego reemplacé:

$font = "arial.ttf";

por:

$fonts = array('timesbi.ttf', 'calibriz.ttf', 'cambriaz.ttf');
$font = $fonts[mt_rand(0, sizeof($fonts)-1)];

Aumentamos el tamaño, le agregamos color y ahora obtenemos las siguientes imagenes donde podemos apreciar el cambio de tipografía en cada ejecución:

Hasta este punto hemos generado un captcha básico que es extremadamente fácil de decodificar.

Para hacer la imágen mas compleja vamos a generar letra por letra. Cada letra tendrá una rotación distinta y acercaremos las letras para lograr un traslape.

Modificamos el código:

imagettftext($im, 20, 0, 11, 21, $fg_color, $font, $text);

por:

$x = 3;
for ($i=0; $i<=6; $i++) {
  $angulo = rand(-12, 12);
  $coords = imagettftext($im, 38, $angulo, $x, 47, $fg_color, $font, substr($text, $i, 1));
  $x += ($coords[2]-$x) - 4;
}

Este código va generando letra por letra y en cada iteración va aumentando la coordenada X restandole algunos pixeles para lograr que el texto se traslape. La rotación de cada letra tendrá un valor comprendido entre el intervalo [-12,12].

Se deberá buscar el valor exacto de traslape con el fin de hacer difícil su decodificación, pero permitiendo que el texto sea legible. Un refinamiento de la generación de estos textos podría ser que cada letra se genere con una tipografía distinta.

Al aplicar estos cambios obtenemos las siguientes imagenes:

Una vez que juntemos todos estos cambios obtendremos el siguiente código:

<php


// Alto y ancho de la imagen
$width  = 250;
$height = 65;
// Tipografia
$fonts = array('timesbi.ttf', 'calibriz.ttf', 'cambriaz.ttf');
// Nombre de la variable de sesion
$session_var = "captcha";
// Condensacion entre cada letra
$condensacion = 4;


// Genero la imagen
$im = imagecreatetruecolor($width, $height);
$bg_color = imagecolorallocate($im, 255, 255, 255);
$fg_color = imagecolorallocate($im, 33, 67, 165);
imagefilledrectangle($im, 0, 0, $width, $height, $bg_color);

// Genero el texto
$font = $fonts[mt_rand(0, sizeof($fonts)-1)];
$text = getCaptchaText(6);
$x = 3;
for ($i=0; $i<=6; $i++) {
  $angulo = rand(-12, 12);
  $coords = imagettftext($im, 38, $angulo, $x, 47, $fg_color, $font, substr($text, $i, 1));
  $x += ($coords[2]-$x)-$condensacion;
}

// Guardo el texto en sesión
session_start();
$_SESSION[$session_var] = $text;

// Genero la imagen
header("Content-type: image/png");
imagepng($im);

// Limpieza
imagedestroy($im);

/**
* Retorna un texto aleatorio
*
* @param int $length Longitud del texto
* @return string Texto aleatorio
*/
function getCaptchaText($length = 6) {
  $consonants = "bcdfghjlmnpqrstvwyz";
  $vocals     = "aeiou";
  $text = "";
  $imax = $length/2;
  for ($i=0; $i<$imax; $i++) {
      $text .= substr($consonants, mt_rand(0, 18), 1);
      $text .= substr($vocals,     mt_rand(0, 4),  1);
  }
  return substr($text, 0, $length);
}

?>

Versión 3
Para dificultar aún más la decodificación le aplicaremos a la imagen un filtro "wave" que genere ondulaciones al texto.

Adicionalmente para aumentar el "ruido" de la imagen la generaré como JPEG en vez de PNG.

Existen otras técnicas bastante eficientes para la mayoría de los casos que consiste en introducir imágenes de fondo y ruido a la imágen como por ejemplo líneas aleatorias o pintar pixeles al alzar. Sin embargo dichas técnicas disminuyen en gran medida la estética del captcha por lo que las descartaré para estos ejemplos.

Para la generación de ondas en la imágen, existen excelentes biblitecas gráficas que permiten hacer esto como por ejemplo ImageMagick. Sin embargo, para continuar con la simplicidad del script utilizaremos una combinación de funciones de GD y funciones trigonométricas. La función de a continuación está basada en un ejemplo publicado en el manual de PHP:


/**
* Filtro wave
*
* Obtenido desde ejemplo publicado en el manual de PHP:
* http://www.php.net/manual/en/function.imagecopy.php#72393
*
*/
function wave_region($img, $x, $y, $width, $height,$amplitude = 4.5,$period = 30) {
// Make a copy of the image twice the size
$mult = 2;
$img2 = imagecreatetruecolor($width * $mult, $height * $mult);
imagecopyresampled ($img2,$img,0,0,$x,$y,$width * $mult,$height * $mult,$width, $height);

// Wave it
$k = rand(-60,60);
for ($i = 0;$i < ($width * $mult);$i += 2) {
    imagecopy($img2,$img2,
              $x + $i - 2,$y + sin($k+$i / $period) * $amplitude,
              $x + $i,$y,
              2,($height * $mult));
}

// Resample it down again
imagecopyresampled ($img,$img2,$x,$y,0,0,$width, $height,$width * $mult,$height * $mult);
imagedestroy($img2);
}

Esta función la llamaremos inmediatamente después de generar el texto con los siguientes argumentos:

// Aplico filtros
wave_region($im, 0, 0, $width, $height, mt_rand(7, 22), mt_rand(25,40));

Una vez que apliquemos este cambio se generarán las siguientes imágenes de referencia:

Al juntar estos últimos cambios y ajustar el tamaño definitivo de la imágen obtendremos el siguiente código:

<php



// Alto y ancho de la imagen
$width  = 180;
$height = 65;
// Tipografia
$fonts = array('timesbi.ttf', 'calibriz.ttf', 'cambriaz.ttf');
// Nombre de la variable de sesion
$session_var = "captcha";
// Condensacion entre cada letra
$condensacion = 4;



// Genero la imagen
$im = imagecreatetruecolor($width, $height);
$bg_color = imagecolorallocate($im, 255, 255, 255);
$fg_color = imagecolorallocate($im, 33, 67, 165);
imagefilledrectangle($im, 0, 0, $width, $height, $bg_color);

// Genero el texto
$font = $fonts[mt_rand(0, sizeof($fonts)-1)];
$text = getCaptchaText(6);

//$text = "captcha"; $font="cambriaz.ttf"; $angulo = 0;

$x = 3;
for ($i=0; $i<=6; $i++) {
  $angulo = rand(-12, 12);
  $coords = imagettftext($im, 38, $angulo, $x, 47, $fg_color, $font, substr($text, $i, 1));
  $x += ($coords[2]-$x)-$condensacion;
}

// Aplico filtros
wave_region($im, 0, 0, $width, $height, mt_rand(7, 22), mt_rand(25,40));

// Guardo el texto en sesión
session_start();
$_SESSION[$session_var] = $text;

// Genero la imagen
header("Content-type: image/jpeg");
imagejpeg($im);

// Limpieza
imagedestroy($im);

/**
* Retorna un texto aleatorio
*
* @param int $length Longitud del texto
* @return string Texto aleatorio
*/
function getCaptchaText($length = 6) {
   $consonants = "bcdfghjlmnpqrstvwyz";
  $vocals     = "aeiou";
  $text = "";
  $imax = $length/2;
  for ($i=0; $i<$imax; $i++) {
      $text .= substr($consonants, mt_rand(0, 18), 1);
      $text .= substr($vocals,     mt_rand(0, 4),  1);
  }
  return substr($text, 0, $length);
}

/**
* Filtro wave
*
* Obtenido desde ejemplo publicado en el manual de PHP:
* http://www.php.net/manual/en/function.imagecopy.php#72393
*
*/
function wave_region($img, $x, $y, $width, $height,$amplitude = 4.5,$period = 30) {
// Make a copy of the image twice the size
$mult = 2;
$img2 = imagecreatetruecolor($width * $mult, $height * $mult);
imagecopyresampled ($img2,$img,0,0,$x,$y,$width * $mult,$height * $mult,$width, $height);

// Wave it
$k = rand(-60,60);
for ($i = 0;$i < ($width * $mult);$i += 2) {
    imagecopy($img2,$img2,
              $x + $i - 2,$y + sin($k+$i / $period) * $amplitude,
              $x + $i,$y,
              2,($height * $mult));
}

// Resample it down again
imagecopyresampled ($img,$img2,$x,$y,0,0,$width, $height,$width * $mult,$height * $mult);
imagedestroy($img2);
}

?>

La evolución del captcha construido fue la siguiente:

Como mejoras a este captcha se podría realizar una seleccón mas exuastiva de las tipografías utilizadas, se le podría añadir una imagen de fondo aleatoria, lineas aleatorias o ruido.

En el siguiente artículo vamos a optimizar el código y aumentar la complejidad del captcha sin perder su estética (es decir no le incorporaré lineas aleatorias, imágenes de fondo, etc.) de una manera similar a los captchas utilizados por Google.

Actualizado el día domingo 1 de junio de 2008.

Protección básica contra Cross-site scripting (XSS)

2008-05-21T23:21:00.000-04:00

Los ataques Cross-site scripting (XSS) o de HTML injection pueden ser prevenidos de manera bastante simple tomando algunas medidas de seguridad básicas que debemos tener siempre presentes.

Este tipo de ataque consiste en incrustar código HTML en un sitio web con el objetivo de poder ejecutar código Javascript arbitraro o incluir código HTML con el fin de -por ejemplo- realizar ataques de phishing.

La preveción de este tipo de ataque se realiza filtrando la infomación que se ingresa y publica en nuestro sitio, por lo que tenemos dos puntos de control:

Filtrar datos ingresados
Escapar datos publicados en la WEB

Filtrar datos ingresados
La media de prevención más sencilla es impedir que los usuarios del sitio puedan publicar información, como por ejemplo cuando se hacen comentarios en un blog o en formularos de contacto.

En caso que el sitio deba permitir el ingreso de información, se debe definir si se aceptará código HTML. En caso que se opte por no aceptar código HTML será necesario filtrar todo el contenido recibido desde formularios para quitar eventuales tags HTML que ingrese el usuario. Esto se puede realizar con la siguiente función:

$comentario = strip_tags($comentario);

La función strip_tags() no realiza validación de que el código HTML esté bien formado, por lo que potencialmente se podría perder información -mal- ingresada por el usuario. Se puede realizar una validación más apropiada por medio de tidy.

En caso que sea necesario permitir el ingreso de código HTML, se deberán restringir los tags HTML que serán permitidos. Usualmente se permiten los tags de texto básico como <p>, <br>, <i>, <b>, <strong>, <em>, <blockquote> y tags de listas como <ul>, <ol> y <li>. Especialmente se debe evitar la inclusión de tags HTML que permitan la inclusión de contenidos externos como por ejemplo <script>, <frame>, <iframe>, <object> y <a>.

El filtrado de los tags HTML permitidos se puede realizar con el siguiente comando:

$comentario = strip_tags($comentario, "<p><br><strong><em>");

Sin embargo, nuevamente la función strip_tags() puede presentar problemas porque los tags admitidos podrían contener atributos peligrosos como onload y onmouseover. Por lo que se debería recurrir a una combinación de tidy y expresiones regulares.

Las tareas de filtrado se pueden enfrentar de dos maneras: Manteniendo una lista negra de tags y atributos no permitidos o manteniendo una lista blanca con los tags y atributos permitidos. En vista de evitar problemas de seguridad, es más recomendable mantener una lista blanca que contenga los elementos admitidos ya que es mucho menos grave restringir el ingreso de un dato inofensivo (falso positivo) que permitir el ingreso de un dato potencialmente peligroso.

Escapar datos ingresados
Como segunda medida de contención se puede agregar validación antes de publicar información en la WEB.

Se debe considerar que la información que ingresa a nuestras bases de datos (y archivos de caché) es introducida por diversos medios, como por ejemplo WebServices, migraciones de datos o SQL Injection, por lo tanto aunque se mantenga absoluta seguridad en nuestros formularios WEB, siempre existe la posibilidad de contar con datos peligrosos. Debido a esto, seimpre es recomendable filtrar la información que se publica en nuestro sitio.

En primer lugar debemos distinguir si la información que publicamos puede contener HTML o no.

En general la gran mayoría de la información que se publica en la web -como por ejemplo nombres, fechas, títulos- no contiene código HTML. En estos casos la información a imprimir en una página web debe ser escapada para reemplazar los caracteres especiales por sus entidades respectivas, esto se realiza con el siguiente comando:

echo htmlspecialchars($nombre);

Esta función tiene la ventaja que imprime correctamente textos como "Barnes & Noble" y "A < B < C" que en caso de no ser escapados no se visualizarían correctamente.

En el caso de publicar contenidos con HTML, se debe aplicar la misma función de filtrado que se utiliza al momento de ingresar datos.

Con estas simples medidas se aumenta en gran medida el nivel de seguridad ante ataques XSS.

Javascript dentro de HTML

2008-05-05T15:00:00.001-04:00

Para incrustar código Javascript dentro de HTML se debe utilizar la siguiente etiqueta HTML:

<script type="text/javascript">
// Aquí va el código...
</script>

Sin embargo, en la actualidad es mejor no utilizar Javascript incrustado sino que más bien utilizar archivos Javascript externos. Esto permite separar el contenido de la programación y además permite una navegación más rápida ya que se pueden guardar en cache los archivos .js externos. El código para referenciar archivos Javascript es el siguiente:

<script type="text/javascript" src="filename.js"></script>

El sentido común nos dice que las referencias a archivos Javascript debieran realizarse en el encabezado del documeno HTML, es decir, dentro de los tags HEAD.

Es mejor hacer lo contrario: por un tema de performance se recomienda -en la medida de lo posible- poner dichas referencias al final del documento HTML ya que esto acelera el proceso de rendering del documento HTML.

Graceful degradation y Unobtrusive Javascript
Cuando se construyen sitios que utilicen Javascript es importante tener en mente mantener la semántica del sitio web y ser conscientes que no todos nuestros visitantes tendrán Javascript habilitado, por ejemplo bots de los motores de búsqeda, usuarios que han deshabilitado javascript por motivos de seguridad, usuarios de algunos dispositivos móviles, microformatos, herramientas semánticas como Yahoo pipes, clientes en modo de sólo texto o -el problema más común- usuarios que visitan nuestro sitio con un navegador que es pacialmente incompatible con nuestro sitio ya sea porque es un navegador antiguo o una versión más moderna. Todos estos usuarios debieran poder navegar por nuestro sitio sin mayores problemas.

El concepto de Unobtrusive Javascript consiste en seguir las buenas prácticas en la programación de Javascript y poder separar el comportamiento (código javascript) del contenido del sitio, es decir que el código Javascript sea lo menos invasivo posible.

El concepto de Graceful degradation consiste en que un sitio web tenga la capacidad de continuar operando con clientes incompatibles proveyendo un nivel de servicios reducido en vez de que este no pueda operar.

Por ejemplo, a continuación se muestran algunos links que hacen uso de javascript de manera incorrecta:

<a href="javascript:link('products')">Productos</a>

<a href="javascript:submitForm('form1')">Enviar formulario</a>

<a href="products.html" onclick="check()">Productos</a>

El primer ejemplo utiliza un llamado a la función link(). Este código no funcionará en navegadores sin soporte a Javascript y hace que sea muy dificil que un robot pueda navegar por el sitio para indexarlo, además atenta contra la usabilidad como por ejemplo hacer clic con el botón central del mouse para abrir el link en una nueva pestaña no funcionará. Este es el caso de Falabella donde no puedo abrir las fichas de productos en distintas pestañas para poder compararlos.

El segundo ejemplo realiza el envío de un formulario mediante código Javascript cuando lo semánticamente correcto habría sido utilizar el elemento HTML <input type="submit"> y en caso de requerir validación del formulario agregar el evento onsubmit al formulario.

El tercer ejemplo ejecuta una función de validación al momento de hacer clic en el link mediante el atributo onclick.

El código correcto para estos 3 ejemplos sería:

<a href="/show/products">Productos</a>

<input type="submmit" id="submitForm" value="Enviar formulario"/>

<a href="products.html" id="linkProducts">Productos</a>

En el primer ejemplo simplemente se reemplazó el código javascript por un link. Se pueden utilizar técnicas como mod_rewrite de Apache para mantener links amigables. En el segundo y tercer caso se utiliza HTML estándar y se referencian los elementos mediante el atributo id mediante el cual podrán ser manipulados por javascript.

Finalmente, agregamos los event handler mediante el siguiente código Javascript:

document.getElementById('linkProducts').onclick = check;
document.getElementById('form1').onsubmit = checkForm;

(NOTA: estos son ejemplos Javascript simplificados que contienen errores de malas práctias como por ejemplo definir directamente los eventos en vez de utilizar una función para agregar eventos en cascada)

SSH Tunneling

2008-05-03T13:30:00.001-04:00

Un problema común
Uno de los grandes problema con que ~~lidio~~ lidiaba en los servidores de producción, es que comúnmente tienen reglas de firewall estrictas que sólo permiten el tráfico TCP/IP por el puerto del servicio que están ejecutando (servidor web, base de datos, FTP, etc.) y el puerto de SSH (22) con fines de administración.

Además en la mayoría de los casos el acceso SSH está limitado sólo desde algunos de los equipos de la red local y en ningún caso permiten el acceso SSH desde Internet.

Esta situación hace muy difícil los procesos de administración, actualización y solución de contingencias ya que la única manera de acceder al servidor era ir físicamente al datacenter o intermediar telefónicamente con un operador que con suerte sabe ejecutar los comandos de shell cd y ls.

Otro problema que se nos puede presentar es la necesidad de encriptar conexiones de protocolos inseguros, como por ejemplo una conexión FTP.

La solución
Una solución para poder acceder a sistemas remotos es estableciendo un Tunnleing SSH, el cual consiste en redirigir (forward) las conexiones TCP dirigidas hacia un puerto específico hacia otro host por medio de la conexión encriptada de SSH. No soporta redirección de paquetes UDP.

En los siguientes ejemplos utilizaremos como ejemplo las siguientes direcciones IP:

Servidor (con acceso restringido): 1.1.1.1
Equipo de administración (tiene acceso al servidor): 1.1.1.2
Equipo local (sin acceso al servidor): 1.1.1.3

El tunneling SSH tiene dos modalidades de redirección: remote port forwarding que permite redirigir conexiones TCP desde el equipo remoto y local port forwarding que permite redirigir las conexiones TCP desde el equipo local.

En shell, la sintaxis tradicional para establecer una conexión SSH es la siguiente:

ssh user@host

La sintaxis para establecer un tunneling consiste en indicar adicionalmente:

El tipo de redirección: "R" para remote port forwarding y "L" para local port forwarding.
El puerto que se redireccionará.
El host y puerto hacia el cual se redigirán los paquetes TCP

Quedando en:

ssh user@host -R port:host:hostport
ssh user@host -L port:host:hostport

En los siguientes ejemplos se utilizará para redirigir conecciones SSH, pero esta técnica sirve para redireccionar cualquier servicio basado en TCP.

Local port forwarding
Si quisieramos acceder por SSH al servidor 1.1.1.1 desde nuestro equipo local 1.1.1.3, el cual no tiene acceso directo, podríamos establecer inicialmente una conexión hacia el equipo de administración 1.1.1.2 y desde ahí establecer un port forwarding hacia el servidor 1.1.1.1 tal como se muestra en el siguiente esquema:

Para eso, desde nuestro equipo local 1.1.1.1 ejecutamos el siguiente comando:

ssh user@1.1.1.2 -L 2222:1.1.1.1:22

Una vez conectado al equipo remoto 1.1.1.2 todas las conecciones desde nuestro equipo local al puerto 2222 serán redirigidas al puerto 22 del servidor 1.1.1.1, con lo cual hemos logrado tener acceso al servidor remoto mediante el siguiente comando:

ssh user@localhost -p 2222

Incluso desde otro equipo que tenga acceso a 1.1.1.3 podrá conectarse al servidor 1.1.1.1 mediante SSH:

ssh user@1.1.1.3 -p 2222

Remote port forwarding
Otra modalidad para acceder al servidor 1.1.1.1 es establecer la conexión opuesta desde el equipo de administración 1.1.1.2 hacia nuestro equipo local 1.1.1.3 como se ilustra a continuación:

En este caso desde el equipo 1.1.1.2 se establecerá un remote port forwarding mediante el siguiente comando:

ssh user@1.1.1.3 -R 3333:1.1.1.1:22

Una vez conectado al nuestro equipo 1.1.1.3 todas las conecciones desde nuestro equipo local al puerto 3333 serán redirigidas al puerto 22 del servidor 1.1.1.1, con lo cual hemos logrado tener acceso al servidor remoto mediante el siguiente comando ejecutado desde 1.1.1.3:

ssh user@localhost -p 3333

SSH desde Windows
Las técnicas de tunneling también están disponibles para Windows, por ejemplo se puede utilizar el programa gratuito putty. La configuración de tunneling se realiza en la siguiente ventana de configuración:

Aplicaciones
Esta técnica nos permite acceder a casi cualquier servicio remoto, como por ejemplo la base de datos del backend o a un sitio web disponible sólo para la intranet.

Además como la conexión se realiza sobre SSH, todas las comunicaciones se realizan mediante un canal encriptado, lo que nos permite dar una mayor seguridad a conexiones vía FTP o a una base de datos.

La técnica de port forwarding es bastante flexible y poderosa, por ejemplo en algunas situcaciones he llegado a realizar hasta 3 tunnelings anidados para lograr alcanzar servidores que están extremadamente resguardados.

UNICODE

2008-04-24T14:47:00.005-04:00

Este es un interesante artículo publicado en el blog oficial de Google para desarrolladores en español sobre la historia de la codificación UNICODE hasta llegar a UTF-8.

El mayor problema con el que os vais a encontrar es la falta de conocimientos sobre internacionalización. Es increíble como muchos programadores, por lo demás perfectamente capacitados, parecen convertirse en Paris Hilton cuando hablan de internacionalización. Eso si llegan a hablar... Vamos a empezar sentando las bases de lo que es un juego de carácteres (charset) y una codificación (encoding). El juego de carácteres es la tabla que traduce de un número a un "carácter" (o para ser más precisos un "codepoint"), y la codificación es el algoritmo que hemos seguido para guardar ese número.

Los invito a seguir leyendo internacionalización I - Unicode en el blog Programa con Google.

Hashing en PHP

2008-04-20T20:33:00.004-04:00

Una de las técnicas más básicas y simples relativas a la seguridad de información es el hashing o codificación de datos sensibles (ej.: contraseñas).

Los algoritmos de hashing permiten generar un hash (o "huella") a partir de un string y tienen la característica principal de que no es posible obtener el string original a partir del hash generado.

La longitud del hash es fija para cada algoritmo por lo que no importa si la entrada tiene una longitud de 1 byte o de varios gigas, el hash tendá siempre la misma longitud. Una de las características básicas de todo hash es que el menor cambio en el string de entrada implica un gran cambio en el hash generado.

Los algoritmos de hash más populares son: MD5, SHA-1 y SHA-2. En la siguiente tabla muestro la longitud de algunos hash y un ejemplo al cifrar el texto "123":

Algoritmo	Bits	Ejemplo
CRC32	32	-2008521774 (representado como int32)
MD4	128	c58cda49f00748a3bc0fcfa511d516cb
MD5	128	202cb962ac59075b964b07152d234b70
SHA-1	192	40bd001563085fc35165329ea1ff5c5ecbdbbeef
SHA-256 (SHA-2)	256	a665a45920422f9d417e4867efdc4fb8 a04a1f3fff1fa07e998e86f7f7a27ae3
SHA-512 (SHA-2)	512	3c9909afec25354d551dae21590bb26e 38d53f2173b8d3dc3eee4c047e7ab1c1 eb8b85103e3be7ba613b31bb5c9c3621 4dc9f14a42fd7a2fdb84856bca5c44c2
RIPEMD-160	160	e3431a8e0adbf96fd140103dc6f63a3f8fa343ab
HAVAL-256	256	e3891cb6fd1a883a1ae723f13ba336f5 86fa8c10506c4799c209d10113675bc1
TIGER-128	128	fe14a796bb0768a83398e6935842229b
TIGER-160	160	fe14a796bb0768a83398e6935842229bbef2eeb0

Como información adicional puedes ver el siguiente sitio que permite generar hashes para múltiples algotirmos.

Debido a que la longitud del hash es de tamaño fijo, existe la posibilidad de que ocurran colisiones, las cuales son extremadamente improblables pero no imposibles, por ejemplo en MD5 teóricamente se pueden generar 3.4 × 10³⁸ (2¹²⁸) valores diferentes de hash y en SHA-256 son casi 1.2 × 10⁷⁷ (2²⁵⁶) valores diferentes.

Aplicaciones

Entre las aplicaciones más comunes de hash se pueden contar las siguientes:

Almacenamiento de contraseñas.
Generación de tokens (ej: para sesión de usuarios, cookies).
Implementación de arreglos asociativos.
Checksums (ej: al transmitir información como un torrent, un instalador o un archivo .ISO).
Digest para firma electrónica (ej: xmlsignature).

A continuación me referiré al almacenamiento de contraseñas.

Almacenamiento de contraseñas mediante HASH
Al guardar las contraseñas codificadas mediante un hash, se imposibilita conocer la contraseña original tanto para un eventual atacante como también para un administrador.

Otro alcance de esta técnica es para que -por políticas de seguridad, cumplimiento de estándares de certificación o por cumplimiento de los términos de uso- la organización no maneje las contraseñas originales de sus usuarios.

El mecanismo más común para autenticar usuarios es por medio de un login y password, lo que implica que en la base de datos exista una tabla que llamaremos usuarios que contiene al menos las columnas usua_login y usua_password, dando como resultado la siguiente tabla de usuarios:

usua_login	usua_password
jessica	p7q,f2
pedro	bonsai
rodrigo	ro123

Como podemos darnos cuenta, cualquiera que tenga acceso a la base de datos podrá conocer la contraseña de los usuarios. Existen muchas técnicas para lograr tener acceso a la base de datos, como por ejemplo errores documentados de software, SQL injection, errores en páginas de inicio de sesión, programas como PhpMyAdmin que no estén lo suficientemente resguardados, usuarios al interior de la organización o ingeniería social.

Por lo tanto el primer nivel de seguridad consiste en guardar las contraseñan cifradas con algún algoritmo de hashing. En la actualidad el algoritmo más popular es MD5, sin embargo desde hace algunos años se han reportado ataques satisfactorios a este algoritmo. Por lo tanto recomiendo utilizar algoritmos de mayor dureza como SHA-1 o SHA-256 los cuales ya están disponibles en muchas herramientas desarrollo. A continuación presento una tabla de las funciones en PHP para codificar en algunos de los algoritmos de hashing:

MD5	md5($txt)
SHA-1	sha1($txt)
sha-256	mhash(MHASH_SHA256, $txt)
tiger-128	mhash(MHASH_TIGER128, $txt)
haval-256	mhash(MHASH_HAVAL256, $txt)

La función hash() requiere tener PHP con el módulo mhash.

En estos ejemplos utilizaré SHA-1, por lo que la tabla usuarios quedará con los siguientes datos:

usua_login	usua_password
jessica	1f9004142372e078dbda694238d82a192760c170
pedro	9562384bbab4d406ee06012638ca65f403d1bd1f
rodrigo	0f8342a2ed2797cb3d19b926d5c98db79b5a8708

Al guardar los datos codificados se debe considerar que las rutinas de inicio de sesión y de gestión de usuarios deben ser intermediadas por un proceso que convierta la contraseña original en la contraseña codificada, como por ejemplo el siguiente código:

$password = "bonsai";
$hash     = sha1($password);

A este nivel hemos logrado que los password se guarden cifrados en la base de datos y sea (teóricamente) imposible conocer los passwords originales. Sin embargo, un atacante que logre acceder a la base de datos aún tendrá posibilidad de conocer algunas de las contraseñas.

Si buscamos en google por la contraseña codificada de Pedro encontraremos inmediatamente que dicho hash corresponde al texto "bonasi". La contraseña de Pedro (bonsai) es conocida como una palabra de diccionario, es decir una palabra común. En internet existen muchos sitios donde tienen indexados millones de palabras con su correspondiente hash -principalmente MD5- por lo que mediante ataques por diccionario es posible obtener las contraseñas de los usuarios más descuidados.

Jessica y en menor medida Rodrigo utilizaron contraseñas que no son palabras de diccionario ("p7q,f2" y "ro123" respectivamente) por lo que es más dificil descubrir sus contraseñas originales.

Lamentablemente, muchos desarrolladores llegan sólo hasta este nivel y descuidan agregar un mayor nivel de seguridad el cual se puede realizar con un cambio muy simple que describo a continuación.

Almacenamiento de contraseñas mediante HMAC
Un algoritmo HMAC no es más que un algoritmo HASH al cual -antes de codificar el texto original- se le añade un texto adicional (key o clave secreta).

En un principio realizabamos la codificacion de la contraseña mediante el siguiente código:

$password = "bonsai";
$hash     = sha1($password);

En este ejemplo vamos a escoger la clave secreta "xy45" y vamos a codificar las contraseñas utilizando la siguiente variación:

$password = "bonsai";
$key      = "xy45";
$hash     = sha1($key.$password);

Es importante que la clave secreta sea lo suficientemente larga y compleja. Recomiendo que la longitud sea de 8 caracteres y se utilicen combinaciones de mayusculas, minusculas, números y caracteres de puntuación. Opcionalmente, en vez de una simple concatenación, PHP provee la función hash_hmac() especialmente diseñada para estos efectos.

Gracias a esta técnica obtendremos la siguiente tabla de usuarios:

usua_login	usua_password
jessica	25062347f18d9e8a85849aade94b38beaea54653
pedro	742cc2861f5c611452bf7e78c8bcbc3899851a56
rodrigo	44f789c9642a64513e8682a7dea072dedae85cd9

Estas contraseñas ahora son invulnerables a un ataque directo de diccionario y por lo tanto brindan un mayor nivel de seguridad. Sin embargo, aún es posible obtener las contraseñas originales por medio de un ataque de colisión.

Si el atacante conoce la clave secreta HMAC, le bastaría con crear un pequeño programa que genere las contraseñas en HMAC a partir de un diccionario de palabras para luego compararlas con las contraseñas almacendas en la base de datos. Si no conoce la clave secreta HMAC, basta con cambiar -por medio de la aplicación- varias veces la contraseña de algún usuario del sistema y luego comparar el string HMAC generado con el del resto de usuarios.

Almacenamiento de contraseñas mediante HMAC con distinta clave secreta
La solución a este tipo de ataque consiste en que la contraseña de cada usuario se codifique con una clave secreta HMAC diferente, como por ejemplo el username, la casilla de correos del usuario o agún otro dato variable. Nuestra nueva función de codificación quedaría de la siguiente manera:

$username = "pedro";
$password = "bonsai";
$key      = "xy45";
$hash     = sha1($key.$username.$password);

En este nuevo escenario aún es posible que un atacante obtenga algún password por colisión pero tendrá que generar un diccionario de claves usuario por usuario.

Otra ventaja -o desventaja según cómo se le mire- es que si se cambia el login del usuario, el password se invalidará. Por lo que en la eventualidad de cambiar el login, se deberá volver a generar el password.

Medidas adicionales de seguridad
Se recomienda mantener oculta la clave secreta HMAC e implementar mecanismos para limitar el registro masivo de usuarios y cambios masivos de contraseña.

También se pueden implementar -a nivel de software- políticas de seguridad a la gestión de contraseñas para no permitir que los usuarios utilicen palabras de diccionario o contraseñas demasiado cortas.

Conversión de UNICODE y LATIN1 en PHP 5

2008-04-10T23:35:00.006-04:00

La principal innovación de PHP 6 será el soporte nativo a UNICODE, sin embargo aún queda un largo camino.

Algunos módulos de PHP 5 internamente ya operan con UNICODE como es el caso de DOM que está desarrollado sobre libxml2, esta característica brinda un gran potencial pero a la vez da muchos dolores de cabeza ya que hay que hacer convivir datos codificados usualmente en ISO-8859-1 (LATIN1) y UTF-8.

Para poder realizar conversiones de codificación PHP provee de las funciones utf8_encode() y utf8_decode(). Sin embargo, es bastante común equivocarse y convertir a UTF-8 datos que ya están en dicha codificación o cometer el mismo error con datos codificados ISO-8859-1 lo cual nos corrompe algunos caracteres y puede causar errores en documentos XML y WebServices.

Este es un ejemplo de errores típicos de codificación:

En otras ocasiones, cuando hay que procesar datos de entrada (ej: leer archivos), uno no sabe de antemano si los datos a procesar vendrán codificados en UTF-8 o ISO-8859-1, o en un peor escenario podrían recibirse datos en ambas codificaciones.

Para solucionar estos problemas he construido unas funciones que detectan la codificación de un string y de esta manera realizan la conversión de codificación sólo si es necesario. Las funciones la he llamado latin1() que convierte los datos a ISO-8859-1 y utf8() que convierte a UTF-8.

Debido a que utilizan la función mb_detect_encoding(), es necesario que PHP tenga habilitado el módulo mbstring.

Función que converte un string a ISO-8859-1 (LATIN1)

function latin1($txt) {
 $encoding = mb_detect_encoding($txt, 'ASCII,UTF-8,ISO-8859-1');
 if ($encoding == "UTF-8") {
     $txt = utf8_decode($txt);
 }
 return $txt;
}

Función que converte un string a UTF-8

function utf8($txt) {
 $encoding = mb_detect_encoding($txt, 'ASCII,UTF-8,ISO-8859-1');
 if ($encoding == "ISO-8859-1") {
     $txt = utf8_encode($txt);
 }
 return $txt;
}

Criptografía en PHP

2008-04-08T20:15:00.015-04:00

La criptografía nos permite cifrar información para que pueda ser accedida sólo por las personas adecuadamente autorizadas.

En informática la criptografía se puede dividir en dos grupos:

Criptografía simétrica: la encriptación y desencriptación se realiza con la misma llave.
Criptografía asimétrica: la encriptación se realiza con una llave y la desencriptación con otra diferente.

Muchos modelos de transmisión de información segura utilizan una combinación de ambos métodos para combinar sus ventajas.

El término "llave", "clave" o en ingles "key" se utiliza para identificar la secuencia de bits utilizada como "clave secreta" para el proceso de cifrar/descifrar la información.

Una regla estándar en la criptografía es que la seguridad debe enfocarse en proteger las llaves de encriptación y no en la ocultación del algoritmo criptográfico (o cipher). De hecho es muy usual que los algoritmos sean públicos.

Criptografía simétrica
La criptografía simétrica se basa en que la misma llave de encriptación se utiliza para desencriptar.

Es relativamente rápido, fácil de implementar e implementable en hardware de bajo costo. Presenta el problema que el emisor y receptor deben conocer previamente la llave de encriptación. Esto nos lleva al problema de cómo transmitirle al receptor la llave de encriptación y este es precisamente el principal problema de este modelo.

Antiguamente el algoritmo más popular era DES (Data Encryption Standard), sin embargo en la actualidad es considerado un algoritmo inseguro ya que la llave de encriptación tiene una longitud de sólo 56 bits, una vez que se declaró este algoritmo como inseguro, se comenzó a utilizar Triple DES que tiene una llave de 158 bits.

En la actualidad el algortimo de cifrado simétrico más popular es AES (Advanced Encryption Standard) también conocido como Rijndael (que es una combinación de lo nombre de sus autores) y la llave puede tener una longitud de 128, 196 y 256 bits.

A continuación incluyo un ejemplo de crifrado utilizando Rijndael-256, es decir utilizamos una llave de 256 bits que es equivalente a los 32 caracteres del ejemplo:

<?php

// Datos de entrada
$texto = 'frase secreta';
$key   = '12345678901234567890123456789012';

// Proceso de cifrado
$iv    = 'abcdefghijklmnopqrstuvwxyz012345';
$td = mcrypt_module_open('rijndael-256', '', 'ecb', '');
mcrypt_generic_init($td, $key, $iv);
$texto_cifrado = mcrypt_generic($td, $texto);
mcrypt_generic_deinit($td);
mcrypt_module_close($td);

// Opcionalmente codificamos en base64
$texto_cifrado = base64_encode($texto_cifrado);

echo "$texto_cifrado\n";

?>

Este ejemplo requiere que PHP tenga habilitado el módulo mcrypt.

A continuación muestro un ejemplo del proceso inverso donde se desencripta la información previamente encriptada:

<?php

// Opcionalmente descodificamos en base64
$texto_cifrado = base64_decode($texto_cifrado);

// Proceso de descifrado
$td = mcrypt_module_open('rijndael-256', '', 'ecb', '');
mcrypt_generic_init($td, $key, $iv);
$texto = mdecrypt_generic($td, $texto_cifrado);
$texto = trim($texto, "\0");

echo "$texto\n";

?>

Criptografía asimétrica
La criptografía asimétrica tiene la característica que utiliza una llave para cifrar y otra para descifrar. Usualmente a una de estas llaves se le denomina clave privada y a la otra clave pública. La clave privada es conocida solo por el propietario de la misma, la clave pública puede ser conocida por todos. Gracias a este modelo se soluciona el principal problema de la criptografía simétrica.

Sin embargo tiene el inconveniente que los algoritmos criptográficos son más complejos, requieren mayor tiempo de procesamiento y el mensaje cifrado requiere de mayor longitud que el mensaje original. Además para proveer el mismo nivel de dureza que la criptografía simétrica (con respecto a ataques de fuerza bruta) requiere de llaves de mayor longitud, como por ejemplo una llave simétrica de 128 bits es aproximadamente equivalente a una llave asimétrica de 1024 bits.

Gracias a la criptografía asimétrica es posible garantizar -entre otros- lo siguiente:

Confidencialidad: Codificar información que solo la pueda descifrar el receptor.
Autenticación: Validar que la persona sea quien dice ser.
Integridad: Asegurar que la información no haya sido alterada (ej: firma electrónica).
No repudio: Asegurar quién es el autor de cierta información.

Más adelante presentaré un ejemplo de cifrado asimétrico, pero antes de eso publicaré un artículo de openssl para enseñar a generar certificados digitales y llaves.

Firma electrónica
La firma electrónica (que es derivada de la criptografía asimétrica) se ha convertido en una herramienta escencial en el desarrollo de aplicaciones y es un estándar de la industria y de gobierno electrónico (e-gov) para el tratamiento de información.

La firma electrónica está construida sobre la infraestructura de llave pública (PKI) y permite asegurar la autoría e integridad de los documentos.

Usualmente la implementación de firma electrónica se realiza en base a la especificación de XML Signature ^[w3c] también conocida como xmldsig.

Actualmente PHP no implementa XML Signature de manera nativa, sin embargo desde PHP 5.2.1 es posible implementarla (planeo a futuro dar algunos ejemplos de su implementación). Además Rob Richards que es miembro del equipo de desarollo de PHP (autor -entre otros- del módulo DOM) está trabajando en un módulo para PHP que ojalá algún día vea la luz.

Haciendo un mirror de subversion

2008-03-27T21:39:00.007-03:00

Subversion -al igual que CVS- es un software de control de versiones, todo desarrollador de software debe contar con una herramienta de este tipo y el no hacerlo simplemente es una gran irresponsabilidad (o estupidez).

Una (pero no la principal) de las ventajas de utilizar subversion es que sirve como una herramienta de respaldo de código. Cuando uno mantiene respaldos, es importante que dichos respaldos sean almacenados en instalaciones diferentes a la fuente de información original, esto permite afrontar situaciones extremas como incendios o terremotos.

Esta condición básica de seguridad no se da en mi caso ya que en mi empresa nuestro servidor subversion está en las mismas instalaciones donde trabajamos, por lo tanto nos vimos enfrentados al problema de respaldar en servidores remotos para lo cual implementé un mecanismo de mirroring de subversion mediante el comando svnsync.

Modelo de operación
El mecanismo que escogí para respaldar subversion es un mirroring que se actualiza cada vez que se hace COMMIT en el repositorio maestro, replicando los cambios en el servidor de respaldo. Este modelo de respaldo tiene las siguientes características:

El mirror está siempre al día.
El mirror es actualizado sólo con los deltas enviados en el COMMIT por lo que la transferencia de datos es mínima.
En caso de pérdida del servidor principal, basta con sacar una copia del mirror para poder restaurar el servidor principal.
El mirror presta las mismas funcionalidades del servidor principal con la excepción que es de sólo lectura.

En términos resumidos la implementación del mirroring se realiza sacando una copia del repositorio, instalarla en un servidor de respaldo y finalmente se configura el servidor principal para que luego de cada COMMIT se ejecute el comando svnsync que replicará todos los cambios en el servidor de respaldo (mirror).

Prerrequisitos
Se asume que tienes conocimientos básicos de LINUX y de cómo administrar un servidor subversion, en caso que no seas muy experimentado puedes consultar el manual de subversion.

IMPORTANTE: El procedimiento aquí descrito se enfoca en el proceso de creación y configuración del mirror. Debes asegurarte de realizar las configuraciones de control de acceso y seguridad necesarias.

Debemos contar con dos servidores (principal y respaldo) que tengan instalado subversion 1.4 o superior, es deseable que ambos servidores tengan la misma versión.

El repositorio a respaldar lo vamos a denominar proyecto. En los ejemplos, el servidor de mirror usará el nombre de dominio mirror.com.

Procedimiento de configuración
El primer paso es crear el repositorio principal (si ya tienes un repositorio que quieres respaldar, puedes omitir este paso).

svnadmin create proyecto

Luego, hacemos una copia del repositorio recién creado, lo comprimimos y eliminamos la copia temporal. (Utilizamos hotcopy para evitar eventuales errores si justo al momento de hacer la copia alguien realizó un COMMIT en el repositorio):

svnadmin hotcopy proyecto proyectobackup
tar cfz proyectobackup.tgz proyectobackup
rm -rf proyectobackup

A continuación transferimos el archivo comprimido al servidor de respaldo, donde lo descomprimimos y restauramos el nombre del repositorio a proyecto:

tar xfz proyectobackup.tgz
mv proyectobackup proyecto
cd proyecto

Ahora configuramos el repositorio mirror para no permitir que los usuarios hagan COMMIT, solamente se permitirá que haga COMMIT una cuenta de usuario especial que llamaremos syncuser, con contraseña secret (debes definir escoger otra contraseña) y le damos permisos de escritura completos:

echo "syncuser = secret" >> conf/passwd
echo "[/]
syncuser = rw" >> conf/authz

(las ultimas 2 lineas son un solo comando)

Para evitar que el resto de usuarios pueda hacer COMMIT creamos el archivo (con permisos de ejecución) hooks/start-commit dentro del repositorio con el siguiente contenido:

#!/bin/sh

USER="$2"
if [ "$USER" = "syncuser" ]; then exit 0; fi

echo "No se permite hacer commit en el repositorio de respaldo" >&2
exit 1

Luego debemos crear el script (con permisos de ejecución) hooks/pre-revprop-change el cual es requerido por el comando svnsync:

#!/bin/sh

USER="$3"

if [ "$USER" = "syncuser" ]; then exit 0; fi

echo "No se permite hacer commit en el repositorio de respaldo" >&2
exit 1

Con estos pasos hemos creado una copia del repositorio proyecto, hemos creado el usuario syncuser y configuramos el repositorio para que nadie más pueda hacer COMMIT. A continuación volvemos al servidor principal.

En el servidor principal vamos a configurar el repositorio para indicarle que tiene un mirror (referenciado en el siguiente ejemplo con el nombre de dominio mirror.com):

svnsync init svn://mirror.com/proyecto svn://localhost/proyecto --username syncuser --password secret

Finalmente ejecutamos el proceso de sincronización, el cual copiará los datos hacia el servidor de respaldo:

svnsync sync svn://mirror.com/proyecto --username syncuser --password secret

Con estos pasos hemos configurado el servidor principal para que apunte al mirror previamente creado. El paso final es automatizar el proceso de respaldo.

Hay dos estrategias para sincronizar el mirror. La primera es realizar la sincronización en un proceso aparte, por ejemplo todas las noches. La segunda estrategia es que la sincronización se realice inmediatamente después de cada COMMIT.

Alternativa 1: Respaldo asincrónico
Esta estrategia es útil cuando la velocidad del enlace entre el servidor principal y el mirror es muy lenta o cuando los COMMITs que se realizan son muy pesados.

Basta con agregar una linea al cron, a continuación se muestra un ejemplo que realiza la sincronización todas las noches a las 04:15 hrs.:

15 04 * * * svnsync sync svn://mirror.com/proyecto  --username syncuser --password secret

Alternativa 2: Respaldo en tiempo real
Esta estrategia tiene la ventaja que el mirror permanecerá siempre actualizado cada vez que hagamos un COMMIT.

Implica editar (o crear) el script ejecutable hooks/post-commit y agregarle el siguiente código:


# Determino el nombre del repositorio
NOMBREREPO=$(echo $REPOS | cut -d"/" -f4)

svnsync sync svn://mirror.com/$NOMBREREPO  --username syncuser --password secret

Luego de esto tendremos nuestro mirror de subversion configurado.

Usando el lenguaje HTML de manera correcta

2008-03-27T12:12:00.001-03:00

El lenguaje HTML es el que le da vida a la web; el requisito fundamental de todo desarrollador web es conocer como mínimo el lenguaje HTML, ya que sobre este se agregan otras tecnologías como CSS y Javascript.

Actualmente la especificación de HTML mayormente recomendada es la XHTML 1.0, la cual en términos simples es HTML pero con las reglas del lenguaje XML. Otras versiones de HTML recomendadas por la W3C son XHTML 1.1, y la más antigua HTML 4.01.

Podríamos resumir las principales reglas de XHTML en las siguientes:

Todos los elementos no vacíos deben tener su tag correspondiente de cierre (<p>hola</p>)
Los tags que originalmente no consideraban tag de cierre deben utilizar la versión reducida de XML, es decir poniendo un slash al final del tag. (<br/>)
Los valores de los atributos deben estar entre comillas simples. (<a href="index.html">)
Los nombres de los tags y atributos HTML deben estar en minúsculas.
Todos los atributos deben tener un valor. (<option selected="selected">)

Adicionalmente XHTML 1.0 incluye 3 variaciones:

XHTML Strict: cumplimiento estricto de la especificación.
XHTML Transitional: permite algunas excepciones de la especificación, es la más comúnmente utilizada.
XHTML Frameset: soporte para frames.

(HTML 4.01 también permite especificar strict, transitional y frameset)

¿Cómo le decimos al browser la versión de HTML a utilizar?
Para indicarle al navegador la versión de HTML, se utiliza una declaración al comienzo del archivo (en la primera línea) denominada DOCTYPE (document type declaration) la cual indica las "reglas" del documento XML.

Para el caso de XHTML 1.0 tenemos las siguientes alternativas ^[w3c]:

XHTML 1.0 Strict

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

XHTML 1.0 Transitional

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

XHTML 1.0 Frameset

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">

Para la mayoría de los casos recomiendo utilizar XHTML 1.0 Transitional.

Quirksmode
Antiguamente no existía esta técnica para poder decirle al navegador la versión de HTML que se está utilizando, por lo que en los casos de las páginas HTML que no incluyan un DOCTYPE, los navegadores utilizan un modo de compatibilidad denominado quirksmode en el cual asumen que la página está construida con técnicas obsoletas y errores comunes del siglo pasado por lo que interpreta la página con reglas diferentes.

WebKit alcanza un 95/100 en el Acid3 test

2008-03-24T23:18:00.003-03:00

WebKit (que es el core de Safari y que está basado en el motor KHTML de Konqueror) acaba de anunciar que su más reciente versión en desarrollo obtuvo un 95% de cumplimiento del test Acid3.

Esto demuestra que Internet Explorer 8 está a años luz del cumplimiento de los estándares ya que recién su versión beta 1 logró cumplir con el test Acid2. Del Acid3 aún ni hablan.

El puntaje para otros motores de navegadores (en su versión de desarrollo) es el siguiente:

Presto (Opera): 77/100
Gecko (Mozilla Firefox): 71/100
KHTML (Konqueror): 62/100
Trident (Internet Explorer): 17/100

La imagen de referencia de Acid3 es la siguiente, que corresponde a un conjunto de pruebas de CSS3, DOM2 y SVG entre otras hierbas.

Además debo decir que la versión Windows de Safari 3.1 recién liberada (con polémica incluida) me dejó gratamente impresionado por su velocidad para renderizar las páginas, tal como profesa su publicidad.

El dilema de Internet Explorer 8

2008-03-22T10:34:00.008-03:00

Desde el momento en que se liberó Internet Explorer 7 -el cual fue un gran avance con respecto a su viejo antecesor IE6- ya se estaba trabajando en la versión 8 del popular navegador.

Una de las principales cualidades que promete esta nueva versión será el gran salto en el cumplimiento de los estándares W3C, específicamente en lo que respecta a XHTML y CSS2.1. La versión beta 1 ya fue liberada y cumple con el acid test 2. Sin embargo, el equipo de desarrollo se está topando con un grave dilema al respecto, digamos que el 99.9% de los sitios de internet no son fieles cumplidores de los estándares por lo que podrían (y van a) ser mal interpretados por Internet Explorer 8.

Esta situación era de esperar ya que el ciclo de desarrollo de un sitio web realizado por desarrolladores "responsables" consiste en desarrollar basado en los estándares para luego probar, corregir y parchar el diseño en base a pruebas en Internet Explorer, Firefox y ocasionalmente Opera y Safari. Y en el caso de los desarrolladores ~~irresponsables~~ "no-responsables" simplemente basta con que se vea bien en IE.

El equipo de desarrollo de Redmond inicialmente tomó la decisión de que su nuevo producto por defecto utilice el modo "IE7 standard-compliant mode", es decir, interpretará el código de un modo que los sitios que actulamente se visualizan correctamente en IE7 sigan haciéndolo y los sitios que cumplan fielmente los estándares deberían poner un tag <meta> para indicar que sean interpretados en "Full standard-compliant mode".

Esta postura causó indignación en los miembros más fanáticos de la comunidad de los estándares web, pero finalmente Microsoft cambió su postura y el nuevo IE8 por defecto interpretará las páginas en "Full standard-compliant mode":

We’ve decided that IE8 will, by default, interpret web content in the most standards compliant way it can. This decision is a change from what we’ve posted previously.

Es una postura que francamente no me esperaba de Microsoft:

We think that acting in accordance with principles is important, and IE8’s default is a demonstration of the interoperability principles in action. While we do not believe any current legal requirements would dictate which rendering mode a browser must use, this step clearly removes this question as a potential legal and regulatory issue. As stated above, we think it’s the better choice.

Ahora bien, este cambio que se vendrá con IE8 augura un gran problema para los actuales sitios ya que deberán realizar correcciones a su código HTML para poder ser correctamente visualizados en IE8. La siguiente es una captura de Google Maps en IE8:

La solución más sencilla es indicarle a IE8 que la página debe ser interpretada como IE7 mediante el siguiente tag <meta> descrito en A List Apart:

<meta equiv="X-UA-Compatible" content="IE=7"/>

Les recuerdo que aún falta mucho tiempo para que IE8 sea liberado por lo que aún pueden aparecer muevas noticias al respecto.

Como artículo relacionado les recomiendo un excelente artículo de Joel on Software (algo que no es novedad en él) que describe de manera magistral el problema de la compatibilidad en la web: Martian Headsets.

Zend Framework 1.5 ya está aquí

2008-03-17T21:21:00.006-03:00

ZEND acaba de liberar la versión 1.5 de Zend Framework, el cual es uno de los mejores frameworks disponibles para PHP.

Esta noticia se suma a la de hace algunas semanas publicada por Andi Gutmans que confirma que Zend Framework formará parte de Ubuntu 8.04 vía el repositorio Ubuntu Universe.

Entre las ventajas de Zend Framework se cuenta con que es un código eficiente, implementa el modelo MVC y posee una gran cantidad de módulos extremadamente útiles.

En mi caso particular no utilizo ningún framework ya que muchas veces agregan un overhead adicional a los scripts y además me obliga a adaptar mi diseño de la aplicación a la de esas herramientas. Por otro lado, este último punto es una de las ventajas de los frameworks, el hecho de obligar al usuario a ser ordenado permite desarrollar código que es más mantenible en el tiempo. Otra de las ventajas evidentes de un framework es que evita tener que reinventar la rueda creando rutinas básicas como por ejemplo control de sesión y manejo de templates lo cual nos permite construir aplicaciones web contando con una base preexistente.

Lo nuevo de PHP 5.3

2008-03-15T15:29:00.014-03:00

La versión actual de PHP es la 5.2.5 y la siguiente versión próxima a ser liberada es la 5.2.6 que principalmente incluye parches que resuelven bugs y problemas seguridad.

Sin embargo, desde hace varios meses se está trabajando en la versión 5.3 que incorporará nuevas funcionalidades que desde hace algún tiempo estaban siendo pedidas por parte de la comunidad. Esta nueva versión debiera ser publicada a mediados de 2008.

Namespaces (¡por fin!)
Sin duda el mayor cambio en esta nueva versión es el soporte a namespaces. Hasta ahora la técnica que se utilizaba para evitar la colisión de nombres era simplemente agregarle un prefijo al nombre de cada clase obteniendo nombres tan largos como: MDB2_Driver_Datatype_Common.

Algunas de las características de la implementación de namespaces son las siguientes:

Namespaces para clases, funciones y constantes.
Múltiples namespaces en un mismo archivo.
Se incorpora la constante __NAMESPACE__.

A continuación incluyo un ejemplo básico de cómo será el uso de namespaces en PHP 5.3:

<?php

namespace DB;
class MyDate {}
$clase1 = new MyDate();

namespace TYPES::BASIC;
class MyDate {}
$clase2 = new MyDate();

var_dump(
get_class($clase1),
get_class($clase2),
);

?>

La salida de este script es la siguiente:


string(10) "DB::MyDate"
string(20) "TYPES::BASIC::MyDate"

En el repositorio CVS de PHP podrán encontrar un README con más detalles de la implementación de namespaces.

Operador "?:"
Esta es otra funcionalidad que llevaba bastante tiempo siendo solicitada por algunos desarrolladores. Su utilidad es similar a la que presta el operador || en javascript, tal como muestro en el siguiente ejemplo donde se le asigna un valor por defecto a las variables width y height:

<script type="text/javascript">

function foo(width, height) {
width  = width  || 640;
height = height || 480;
// ...
}

</script>

En PHP podríamos hacer las siguientes validaciones:

<?php

$a = true ?: false;               // true
$a = false ?: true;               // true
$a = "" ?: 1;                     // 1
$a = 0 ?: 2;         // 2
$a = array() ?: array(1);         // array(1)
$a = strlen("") ?: strlen("a");   // 1

?>

Este ejemplo fue obtenido de http://ilia.ws

Como vemos no es una super-hiper-killer-funcionalidad, pero para los usuarios habituados a javascript es un placer contar con ella.

Otras mejoras
Otras mejoras -además de las habilituales correcciones de bugs, mejoras en seguridad y optimización de código- incluidas en PHP 5.3 son las siguientes:

Mejora en performance de md5().
Optimización de manejo de excepciones.
Nueva constante __DIR__. (esto nos evitará hacer dirname(__FILE__))
Nueva función mágina __callStatic() que complementa a __call().
El procesamiento de métodos estáticos se movió desde el tiempo de compilación a tiempo de ejecución (Late Static Binding).
Nuevo driver nativo de MySQL (MySQLnd) diseñado especialmente para PHP.
Soporte para archivos .ini (al estilo de .htaccess).
Nuevas funcionalidades de OpenSSL destinadas a simplificar las implementaciones de OpenID en PHP.
Profiling de XSLT. ($xsltprocessor->setProfiling("/tmp/profile.txt"));
Nueva constante de error E_DEPRECATED.
Garbage collector (gc_enable()).
NOWDOC, similar a los HEREDOC pero que no interpreta las variables como $myvar.

Manteniendo PHP al día

2008-03-14T19:00:00.001-03:00

Uno de los dolores de cabeza con que tuve que lidiar hasta hace algún tiempo fue que las diversas distribuciones de linux incluían versiones antiguas de PHP por lo que tenía que compilar el código fuente para tener versiones más recientes.

Tengo dos motivos principales para querer instalar versiones de PHP actualizadas:

En cada release se corrigen innumerables bugs detectados en las versiones anteriores.
Nuevas funcionalidades que se agregan a PHP, como por ejemplo en la versión 5.2 se incorporó soporte para canonicalización ^[W3C] (C14N) las cuales son imprescindibles para la firma electrónica en XML ^[W3C] (XMLDsig).

Comúnmente para instalar una versión reciente de PHP compilaba el código fuente, lo cual toma bastante tiempo y puede ser bastante engorroso en caso de que el sistema operativo no tenga todas las dependencias para compilar, la desinstalación de código compilado siempre ha sido difícil y para qué hablar del proceso de actualización de versión en ambientes productivos, siempre era una incógnita cuánto iba a demorar la actualización (y mientras el sistema está detenido sin dar servicio a los clientes). Siempre he preferido administrar los paquetes mediante RPM ya que facilita mucho la instalación y desinstalación de software, la actualización de versión es bastante rápida, por lo general uno no se topa con sorpresas durante la instalación y el procedimiento de vuelta atrás es bastante sencillo ya que consiste sólo en volver a instalar los RPM de la versión previa.

Un día, todas estas preocupaciones quedaron en el olvido gracias a Remi Collet quien matiene un repositorio de paquetes RedHat que incluye las versiones más recientes de PHP. Usualmente el repositorio se actualiza en no más de una semana después de que PHP libera una actualización. Además, incluye módulos PEAR y PECL para PHP y actualizaciones para MySQL, Firefox y Thundebird.

Una vez configurado correctamente el repositorio, basta con ejecutar el siguiente comando para actualizar PHP a la versión más reciente:


yum update php

Al ser orientado a RedHat, el repositorio cuenta con releases para las versiones más comunes de Fedora Core, CentOS y RedHat. Además publica los SRPM, es decir, los RPM que contienen los códigos fuentes lo cual permite que uno recompile y genere sus propios RPM. Provee de instrucciones de instalación para yum, apt y smart.

Como nota final, tengo que aclarar que no es recomendable estar actualizando el software con demasiada frecuencia ya que cada proceso de actualización requiere de pruebas exhaustivas y eventualmente podría comenzar a fallar código que antes funcionaba correctamente.

Motivación

2008-03-13T22:47:00.008-03:00

Cada vez que participo en un proyecto de software aprendo una enormidad de nuevos temas que de alguna manera las quiero ir dejando registradas. Usualmente son temas que han requerido de bastante tiempo de investigación o son producto de la experiencia.

Hace más de un año que tomé la decisión de crear un blog para ir registrando información útil e interesante relacionada con mi trabajo en desarrollo web, sin embargo había pospuesto su inicio debido a que no había decidido la orientación que le iba a dar.

Finalmente tomé la decisión de que si no comenzaba a publicar ahora mismo, no lo iba a hacer nunca por lo que aproveché la contingencia del retraso del cambio de hora en Chile para bautizar mi blog y comenzar a publicar algunos artículos.

Existen cientos de sitios que hablan sobre PHP, Apache, javascript, XML, firma electrónica y otros temas. Sin embargo, casi todos hablan de lo mismo y son pocos los que profundizan en temas específicos. En base a esto, la orientación de este blog no será hablar de temas básicos -y ser uno más de esos cientos de sitios- sino que trataré temas más específicos pero que han sido extremadamente útiles en mi trabajo.

Hay varios temas que me interesan y no tengo claro por cuál voy a comenzar, algunos de los artículos que estoy preparando son:

Usando HTML y XHTML correctamente
Firma electrónica usando OpenSSL y PHP
Encriptación en PHP
Recomendaciones para almacenamiento de password
Trabajar con XML en PHP
Buenas prácticas en PHP
Compilación y generación de RPMs de PHP
Compilación de módulos PECL para PHP
Cración de módulos PECL para PHP (programar en lenguaje C)
Memcache
Optimización de apache: Configuración de cache
Optimización de apache: Compresión de datos
Redescubriendo javascript
Biblioteca YUI para javascript
Manipulación de DOM mediante javascript
Convivieno con UTF-8
Desarrollando con Firebug
OpenID
WebServices y SOAP

PHP y las zonas horarias

2008-03-08T16:50:00.013-03:00

Abstract
Debido a la modificación del cambio de horario en Chile para este año 2008 que traslada el término de horario de verano desde la noche del 8 de marzo hacia la noche del 29 de marzo, nos hemos topado con la necesidad de corregir nuestros sistemas para que se adapten a este cambio.

En LINUX, la solución más apropiada es la actualización manual de la definición de la zona horaria America/Santiago o (idealmente) la actualización del paquete tzdata (una vez que hayan publicado la actualización correspondiente).

Sin embargo, algunos software como por ejemplo PHP y JAVA mantienen su propia información de zona horaria (zoneinfo) por lo que ingnorarán las reglas que tenga definido el sistema operativo. Esto significa que -aunque yamos parchado nuestro sistema operativo- mantendrán el problema del cambio de hora.

Solución para PHP
PHP desde la versión 5.1 mantiene su propia base de datos de zona horaria por lo que ignorará las reglas de zona horaria definidas en el Sistema Operativo. La solución a este problema es la actualización del módulo timezonedb incluido con PHP. Lamentablemente al 8 de marzo de 2008 la versión más reciente de timezonedb no incluye la actualización a la zona horaria America/Santiago por lo tanto tendremos que parchar el módulo antes de instalarlo.

Gestión de módulos en PHP mediante PECL
PHP está compuesto por un core llamado Zend Engine y un subconjunto de módulos que le agregan funcionalidades como manejo de strings, manejo de fechas, soporte a sesiones, etc. El conjunto de módulos adicionales de PHP se llama PECL.

Es posible agregar módulos PECL adicionales que no vienen incluidos en la distribución original mediante el comando pecl el cual viene en el paquete php-devel.

En las distribuciones RedHat y sus derivados (Fedora Core, CentOS, etc.) la instalación de paquetes se puede realizar con el comando yum, el cual utilizaré como ejemplo en este artículo. En otras distribuciones existen otros gestores de paquetes y los nombres de los paquetes podrían variar.

En caso que no tengamos el paquete php-devel, lo instalamos con el comando:

yum install php-devel

Ahora que contamos con el comando phpize, el procedimiento para instalar cualquier módulo PECL es el siguiente:

pecl instal nombre_paquete

Por lo tanto, para instalar el módulo timezonedb se ejecutaría el siguiente comando

pecl install timezonedb

~~Sin embargo, tal como indiqué al principio, esto no resolverá el problema porque en este momento (8 de marzo de 2008), este módulo aún no incorpora la actualización para America/Santiago~~.

Actualizado: Hace algunos días publiqué un bug en el sitio de PHP y se acaba de liberar la versión de timezonedb que actualiza la zona horaria para America/Santiago, por lo que desde ahora ya no es necesario realizar los pasos que indico en "Instalar módulo timezonedb parchado" sino que simplemente se debe ejecutar el comando indicado a continuación y luego seguir con los pasos indicados más abajo en "Habilitando extensión":

pecl install timezonedb

Instalar módulo timezonedb parchado
El procedimiento a seguir es descargar los fuentes de timezonedb (que están en lenguaje C), modificar la definición de la zona America/Santiago y luego agregar el módulo a PHP. Este procedimiento requiere de conocimientos básicos del lenguaje C.

En primer lugar descargamos los fuentes mediante:

pecl download timezonedb

Esto descargará un archivo con la versión más reciente del módulo que en mi caso fue timezonedb-2007.11.tgz. Lo descomprimimos y entramos al directorio recien creado:

tar xfz timezonedb-2007.11.tgz
cd timezonedb-2007.11

El archivo timezonedb.h es el que contiene la información de las zonas horarias. He publicado una versión parchada que contiene la información actualizada para America/Santiago en base a la versión timezonedb-2007.11. A contnuación descargamos y descompriminos el archivo.

wget http://www.joserodriguez.cl/blog/2008/03/timezonedb.h.gz
gunzip timezonedb.h.gz

Luego, estamos en condiciones de compilar el módulo ejecutando los siguientes comandos:

phpize
./configure
make

Luego, como usuario root, instalamos el módulo.

make install

Habilitando extensión
Habilitamos la extensión en el archivo php.ini el cual usualmente se encuentra en /etc/php.ini. En algunas distribuciones tales como UBUNTU existen dos archivos php.ini, ambos deben ser actualizados.

echo "extension=timezonedb.so" >> /etc/php.ini

Validando instalación
Para verificar que la actualización funcione correctamente podemos ejecutar el siguiente script:

<?php

f(1204988400);
f(1205074800);
f(1206802800);
f(1206889200);

function f($time) {
echo date("Y-m-d G:i:s O e I\n", $time);
}

?>

Cuya salida debería ser la siguiente:

2008-03-08 12:00:00 -0300 America/Santiago 1
2008-03-09 12:00:00 -0300 America/Santiago 1
2008-03-29 12:00:00 -0300 America/Santiago 1
2008-03-30 11:00:00 -0400 America/Santiago 0

En caso que ocurra algún error fatal al ejecutar PHP, como por ejemplo segmentation fault, se puede deshabilitar la extensión eliminando la línea recien agregada a php.ini.

Actualizado el 16 de marzo de 2008.

¿Cómo corrijo la zona horaria?

2008-03-07T16:16:00.010-03:00

En vista del retraso de este año en el cambio de la zona horaria para Chile intentaré describir el manejo de la hora en los sistemas computacionales y dar algunas luces de cómo es el procedimiento adecuado para actualizar el cambio de hora. He omitido algunos conceptos y generalizado en algunos aspectos con el fin de no hacer tan compleja la explicación.

Si no han vivido en una caverna durante toda su vida, debieran saber que el planeta tierra se divide en 24 husos horarios donde cada uno posee una diferencia de una hora con respecto al contiguo. Por efectos prácticos cada país hace coincidir el huso horario con sus limites geográficos y utiliza el término de zona horaria.

Todos los husos horarios o zonas horarias se definen en función del Tiempo universal coordinado (UTC) el cual está fijado en el meridiano de Greenwich (GMT-0), de esta manera nuestro país normalmente está en GMT-4.

Ahora bien, cada país realiza algunos ajustes en su horario, por ejemplo Chile en la época estival utiliza el horario de verano el cual nos mueve desde GMT-4 a GMT-3. Debido a que es complejo saber todas las reglas de cada país, se definen nuevas zonas horarias que para el caso de Chile son America/Santiago en el territorio continental y Pacific/Easter para la isla de Pascua.

Como vivimos en un mundo globalizado, podríamos asumir que la "hora oficial del mundo" es la correspondiente a GMT-0 (simplemente GMT o UTC), de hecho nuestros computadores almacenan todas las fecha en GMT.

Por ejemplo, (aquí en Chile: America/Santiago) si tengo que agendar una reunión el 10 de enero (que corresponde al horario de verano), al registrar la fecha "10 de enero de 2008 15:00:00" mi software de agenda -antes de guardarla en su base de datos- la convertirá a hora "universal" (o GMT) por lo que le sumará 3 horas quedando guardada como "10 de enero de 2008 18:00:00". Luego, cada vez que mi agenda me muestre la fecha, leerá la fecha en GMT, la modificará según mi zona horaria y luego de eso me la mostrará.

Compliquemos las cosas...
Lo estándar es que el término del horario de verano (regresar de GMT-4 a GMT-3) fuese el segundo sábado de marzo (al final del día), pero para este año 2008 el cambio se realizará el sábado 29 de marzo.

Para los usuarios domésticos, tener algunas fechas equivocadas puede ser aceptable, pero en sistemas corporativos eso puede ser muy peligroso.

Alternativa N°0: Sincronizar con un servidor ntp (servidor de hora)
Un servidor de hora permite que nuestro equipo tenga la hora actualizada, pero estos servicios conversan en UTC y luego el equipo local ajusta la hora local en base a la zona horaria, por lo tanto no sirve para el problema del cambio de hora. De todos modos es una buena práctica tener nuestro equipo sincronizado con ntp.shoa.cl.

Alternativa N°1: Adelantar la hora
La solución más sencilla que a uno se le ocurre es que -luego de que suceda el cambio de hora- adelantemos el reloj del sistema y luego el 29 de marzo volver a retrasarlo. Este cambio haría que todas las fechas almacenadas entre el 9 y 29 de marzo queden guardadas erróneamente ya que en vez de considerarlas como GMT-4 (horario de verano) las tomará como GMT-3.

Repitamos el ejemplo inicial: Si agendo una reunión para el día 12 de marzo a las 10:00 (hora local America/Santiago), el sistema -al convertirla a UTC- le aplicará la corrección GMT-3 (le sumará 3 horas) convirtiéndola erróneamente en "12 de marzo de 2008 13:00:00" cuando lo correcto es sumarle 4 horas y almacenarla como "12 de marzo de 2008 14:00:00".

Si envío la cita a los demás asistentes, ellos podrían recibir la cita con una hora de anticipación pudiendo pasar más de un mal rato. Mientras nuestro software (o sistema operativo) no actualice las reglas de la zona horaria de America/Santiago este error pasará desapercibido en mi computador porque tanto al guardar la fecha como al leerla utilizará la misma zona horaria GMT-3. Cuando a futuro haga una actualización de mi software (o sistema operativo) es posible que se haya incluido la actualización de la zona horaria y ahí quedaría en evidencia el error haciendo que todas las fechas ingresadas durante esas 3 semanas estén adelantadas en una hora.

Alternativa N°2: Cambiar la zona horaria a GMT-4
Otra alternativa es cambiar la zona horaria manualmente a GMT-4 (cuya zona horaria es ETC/GMT+4, el signo "+" es correcto) para forzar el uso del horario de verano y luego el 29 de marzo volver a America/Santiago. Esto hará que las fechas se almacenen correctamente ya que no habremos cambiado la hora de nuestro computador, pero tiene el inconveniente que asumirá que todas las fechas están en GMT-4 por lo que al consultar una fecha del horario de invierno (por ejemplo "18 de septiembre de 2007 10:00:00"), en vez de restarle 3 horas a la fecha GMT que está almacenada en el sistema, le restará 4.

Alternativa N°3: Actualizar la "definición" de la zona horaria
La solución correcta es actualizar la definición de la zona horaria, es decir, que el sistema sepa que en 2008 el término del horario de verano para America/Santiago es el 29 de marzo y no el 9 de marzo.

El problema de esta solución es que no es fácil realizar el cambio, ya que usualmente consiste en realizar cambios a archivos del sistema operativo o al registro de Windows.

Solución para Windows
Para servidores Windows, Microsoft publicó un comunicado donde recomienda la cambiar la zona horaria (nuestra alternativa N°2) para usuarios domésticos y la actualizar la definición de la zona horaria America/Santiago (nuestra alternativa N°3) para usuarios corporativos.

Solución para LINUX
En servidores LINUX (y en general *NIX) la información de las zonas horarias es mantenida por el paquete tzdata, sin embargo a la fecha de escritura de este artículo, dicho paquete aún no contiene la actualización a nuestra zona America/Santiago, por lo tanto la solución es regenerar la definición del archivo de zona. A continuación describo el procedimiento para distribuciones RedHat, Fedora y CentOS. En otras distribuciones es posible que los comandos y ubicación de los archivos sea distinta.

Al momento de escribir este artículo UBUNTU ya cuenta con una actualización del paquete tzdata: https://bugs.launchpad.net/ubuntu/+source/tzdata/+bug/198129.

Si bien hay muchos servicios que utilizan el sistema operativo para el manejo de la zona horaria, hay software que mantiene su propio módulo de zonas horarias por lo que ignorará estos cambios, por ejemplo (algunas versiones de): PHP 5.1+, ORACLE y JAVA.

Actualizado: Ya se publicó la actulización oficial de tzdata 2008a por lo que ahora -si lo prefieres- en vez de crear el archivo tzdata.txt que indico más abajo, puedes descargar el archivo oficial y luego importar el archivo southamerica como indico a continuación:

cd /tmp
wget ftp://elsie.nci.nih.gov/pub/tzdata2008a.tar.gz
tar xfz tzdata2008a.tar.gz
zic southamerica

En caso que prefieras no descargar el archivo anterior, se debe crear el archivo newzone.txt con el siguiente contenido:


Rule Chile  1927 1932 -  Sep   1    0:00   1:00 S
Rule Chile  1928 1932 -  Apr   1    0:00   0  -
Rule Chile  1942 only -  Jun   1    4:00u  0  -
Rule Chile  1942 only -  Aug   1    5:00u  1:00 S
Rule Chile  1946 only -  Jul  15    4:00u  1:00 S
Rule Chile  1946 only -  Sep   1    3:00u  0:00 -
Rule Chile  1947 only -  Apr   1    4:00u  0  -
Rule Chile  1968 only -  Nov   3    4:00u  1:00 S
Rule Chile  1969 only -  Mar  30    3:00u  0  -
Rule Chile  1969 only -  Nov  23    4:00u  1:00 S
Rule Chile  1970 only -  Mar  29    3:00u  0  -
Rule Chile  1971 only -  Mar  14    3:00u  0  -
Rule Chile  1970 1972 -  Oct  Sun>=9  4:00u  1:00 S
Rule Chile  1972 1986 -  Mar  Sun>=9  3:00u  0  -
Rule Chile  1973 only -  Sep  30    4:00u  1:00 S
Rule Chile  1974 1987 -  Oct  Sun>=9  4:00u  1:00 S
Rule Chile  1987 only -  Apr  12    3:00u  0  -
Rule Chile  1988 1989 -  Mar  Sun>=9  3:00u  0  -
Rule Chile  1988 only -  Oct  Sun>=1  4:00u  1:00 S
Rule Chile  1989 only -  Oct  Sun>=9  4:00u  1:00 S
Rule Chile  1990 only -  Mar  18    3:00u  0  -
Rule Chile  1990 only -  Sep  16    4:00u  1:00 S
Rule Chile  1991 1996 -  Mar  Sun>=9  3:00u  0  -
Rule Chile  1991 1997 -  Oct  Sun>=9  4:00u  1:00 S
Rule Chile  1997 only -  Mar  30    3:00u  0  -
Rule Chile  1998 only -  Mar  Sun>=9  3:00u  0  -
Rule Chile  1998 only -  Sep  27    4:00u  1:00 S
Rule Chile  1999 only -  Apr   4    3:00u  0  -
Rule Chile  2000 2007 -  Mar  Sun>=9  3:00u  0  -
Rule Chile  2008 only -  Mar  30    3:00u  0  -
Rule Chile  1999 max  -  Oct  Sun>=9  4:00u  1:00 S
Rule Chile  2009 max  -  Mar  Sun>=9  3:00u  0  -
Zone America/Santiago  -4:42:46 -    LMT    1890
-4:42:46 -  SMT  1910
-5:00  -    CLT    1916 Jul  1
-4:42:46 -    SMT    1918 Sep  1
-4:00  -    CLT    1919 Jul  1
-4:42:46 -    SMT    1927 Sep  1
-5:00  Chile  CL%sT  1947 May 22
-4:00 Chile CL%sT
Zone Pacific/Easter    -7:17:44 -    LMT    1890
-7:17:28 -  EMT  1932 Sep
-7:00 Chile   EAS%sT  1982 Mar 13 21:00
-6:00 Chile   EAS%sT
Link America/Santiago        Chile/Continental
Link Pacific/Easter          Chile/EasterIsland

se debe ejecutar como usuario "root" el comando:

zic  newzone.txt

luego, para verificar que haya quedado bien configurado, se debe ejecutar:

zdump -v America/Santiago | grep 2008

y verificar que en dos de las reglas de cambio de horario indique 30 de marzo (Sun Mar 30). En mi LINUX la salida de este comando es:

America/Santiago  Sun Mar 30 02:59:59 2008 UTC = Sat Mar 29 23:59:59 2008 CLST isdst=1 gmtoff=-10800
America/Santiago  Sun Mar 30 03:00:00 2008 UTC = Sat Mar 29 23:00:00 2008 CLT isdst=0 gmtoff=-14400
America/Santiago  Sun Oct 12 03:59:59 2008 UTC = Sat Oct 11 23:59:59 2008 CLT isdst=0 gmtoff=-14400
America/Santiago  Sun Oct 12 04:00:00 2008 UTC = Sun Oct 12 01:00:00 2008 CLST isdst=1 gmtoff=-10800

Luego hay que ejecutar la herramienta para configurar la zona horaria system-config-date (puede ser por linea de comandos o en el entorno gráfico), escoger America/Santiago y luego "Aceptar".

Algunos servicios requieren ser reiniciados para reconocer los cambios, en caso de ser posible es mejor reiniciar el equipo.

PHP
Tal como comentaba más arriba, PHP desde la versión 5.1 incluye su propio módulo de zona horaria por lo que ignorará las reglas de la zona horaria del sistema operativo. En este caso se puede realizar otro procedimiento que comento aquí.

(Actualizado el domingo 9 de marzo a las 11:30)