No hace mucho puse en marcha en varios servidores un interesante monitor de servicios que es capaz de ejecutar comandos y lanzar alertas que nosotros programemos ante determinadas condiciones que fijemos.

Es capaz de monitorizar cualquier tipo de servicio o demonio, archivos de disco o sistema, vigilar espacios de discos, identificadores de proceso PID, realizar checksum y muchísimas cosas más, su forma de configurar es tan potente que configurarlo resulta en casi un lenguaje de programación.

Sin embargo no hay que asustarse, ya que es tremendamente intuitivo.

La maravilla de que les hablo se llama MONIT y es de licencia libre.

Advertencia: Este artículo es para profesionales que están plenamente familiarizados con servidores Linux. No me hago responsable de ningún daño en su sistema.

Lo primero es bajarnos una copia del programita, al momento de redactar este tutorial la versión estable es la 5.1.1. (no olvides que todo esto has de realizarlo como ROOT del sistema)

wget http://mmonit.com/monit/dist/monit-5.1.1.tar.gz
tar zxvf monit-*
cd monit*
./configure --without-ssl
make && make install

Bien, ya lo hemos instalado… la opción –without-ssl es opcional pero yo la prefiero para evitar que el monitor web que veremos más adelante tenga que necesariamente usar un protocolo HTTPS.

Bien, ya está instalado pero debemos saber que aunque esté instalado faltan 2 cosas: el archivo de configuración y colocarlo como demonio (servicio que se auto-ejecuta cada vez que arranquemos nuestro servidor).

Primero, vamos a preparar a monit como un servicio activo:

cp contrib/rc.monit /etc/init.d/monit
chmod 755 /etc/init.d/monit
ln -s /usr/local/bin/monit /usr/bin/monit
chkconfig --add monit
chkconfig monit on

Y ahora nuestro archivo de configuración principal /etc/monitrc y la carpeta /etc/monit donde colocaremos de forma ordenada e independiente cada ‘monitor’ que deseamos establecer :

touch /etc/monitrc
chmod 700 /etc/monitrc
mkdir /etc/monit

Y nuestro archivo de configuración /etc/monitrc:

# Monit control file
# ==================

# Monit global settings:
# ----------------------
set daemon  60
set logfile syslog facility log_daemon
set mailserver localhost
set alert usuario@dominio.com # direccion a donde enviaremos las alertas del sistema
set mail-format {
from: monit@localhost
subject: $SERVICE $EVENT
message: $ACTION $SERVICE at $DATE on $HOST: $DESCRIPTION.
}

set httpd port 2812 and
allow xxx.xxx.xxx.xxx # La IP remota que tendrá permiso para poder ver el monitor web
allow usuario:clave #pues eso... los permisos que necesitas para poder entrar al monitor vía web

include /etc/monit/server.monit
include /etc/monit/httpd.monit
include /etc/monit/mysqld.monit

Como podrán ver este archivo de configuración permite establecer cada cuanto tiempo realizar la revisión, el formato de correo, remitente y destinatario, servicios que activaremos (con include), y acceso al puerto 2812 vía web con usuario y clave (no olvides abrir este puerto en tu firewall)

Listo, ahora vienen los archivos de configuración de cada servicio:

server.monit:

# Monit Server  settings:
# ----------------------
check system xxx.xxx.xxx.xxx #IP de tu host
if loadavg (1min) > 5 then alert
if loadavg (5min) > 10 for then alert
if memory usage > 90% then alert
if cpu usage (user) > 70% for 3 cycles then alert
if cpu usage (system) > 30% for 3 cycles then alert
if cpu usage (wait) > 20% for 3 cycles then alert

httpd.monit:

#
# Monitor Apache (httpd)
#
check process httpd with pidfile /var/run/httpd.pid
start program = "/etc/init.d/httpd start"  with timeout 60 seconds
stop program  = "/etc/init.d/httpd stop"
if totalcpu > 90% for 3 cycles then restart
if totalmem > 95% for 3 cycles then restart
if children > 250 for 3 cycles then restart
if cpu > 70% for 3 cycles then restart
if failed host xxx.xxx.xxx port 80 protocol http then restart #IP de tu host

mysqld.monit:

check process mysql with pidfile  /var/run/mysqld/mysqld.pid
group database
start program = "/etc/init.d/mysqld start"
stop program = "/etc/init.d/mysqld stop"
if cpu > 95% for 2 cycles then restart
if memory usage > 75% then restart
if failed host xxx.xxx.xxx port 3306 protocol mysql then restart #IP de tu host

Listo, cada quien se puede ajustar sus monitores a su gusto, hay muy buena documentación y muchos ejemplos

Respecto a monit, sólo resta ponerlo a andar:

/etc/init.d/monit restart

Verificar las sintaxis de nuestros archivos de configuración:

monit -t

Y si queremos “recargar” nuestro monitor para releer los archivos de configuración sin necedad de parar el servicio, podemos hacer:

monit reload

Ce tout !, para ver nuestro monitor vía web: http://xxx.xxx.xxx.xxx:2812 (IP del servidor)

Lo demás es lectura, experimentación y curiosidad… las posibilidades son casi infinitas !

Y aquí lo tienen… y libro que SitePoint regaló por 24 horas, tras hacerse España con la copa del mundial de fútbol 2010.

El libro podía descargarse desde este enlace http://sale.sitepoint.com/ (yo me he bajado el mío) pero por si acaso llegaron tarde a la piñata, acá les dejo el cotillón: http://www.mediafire.com/?uez2d0m2dm2

Habrá quien piense distinto, pero este artículo lo pongo (como suele ser costumbre) como una nota mental ;-) ya que el enlace es bastante escurridizo y no suele encontrarse fácilmente al buscarlo por allí.

<script type="text/javascript" src="http://code.jquery.com/jquery-latest.js"></script>

También podríamos valernos de google para cargar remotamente, pero con la desgracia de que debemos especificar a mano la versión deseada, en este ejemplo la versión 1.4.2:

<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js"></script>

Seguro le será de ayuda a alguno.

Como muchos saben un archivo con la forma .xxx en Linux representa a un archivo “oculto” y por tanto una simple instrucción GREP o FIND no nos servirían de mucho a no ser que las usemos combinadas.

Así pues que la solución la dejo por acá en forma de nota mental para mis usos futuros (y el de ustedes).

find . -name ".htaccess" -exec grep -r -n -H -I 'cadena-a-buscar' {} \;

Esta instrucción la ejecutamos desde luego desde el directorio donde deseamos iniciar la recursividad, en mi caso:
/var/www/vhosts (plesk)

Sucede mucho que ante ciertos CMS como foros, blogs, portales, etc… el mod_security dispara incómodos falsos-positivos, y por ende dichos sistemas instalados dejan de funcionar como esperamos que lo hagan.

La solución es simple: Analizar los logs en búsqueda de la razón de estos falsos positivos y ajustar las reglas del mod_security pero, siempre hay una opción mucho más rápida: deshabilitar el mod_security (Aunque evidentemente esto deja sin protección al sistema)

Pero ¿cómo hacemos esto si el mod_security al ser un plugin del Apache que afecta en general y por igual a todos los dominios hospedados en un mismo servidor?

Pues fácil:
Creamos (o editamos) el archivo .htaccess el cual está en la raíz del dominio que queremos deshabilitarle el mod_security y ya está:

<IfModule mod_security.c>
SecFilterEngine Off
</IfModule>

Inicialización de variables PHP

Consideremos el siguiente código:

<?php
if (authUser($_POST["login"], $_POST["password"])) {
    $auth = true;
}
if ($auth) {
    echo "Secret\n";
}
?>

Puedes detectar fácilmente la vulnerabilidad en el mismo. La variable $auth no se inicializó para todos los casos por lo que puede ser engañada desde el exterior. PHP define una forma de manejar las variables sin inicializar (a diferencia del lenguaje C, por ejemplo), todos ellos tienen el valor null. El problema es que la variable se puede inicializar de otras fuentes:

• Código Anterior.
• Archivo incluido (include)
• Remotamente si register_globals está habilitado.
• Usando el extract de una variable (no fiable).

Defensa:
Defenderse de este tipo de vulnerabilidad es muy simple – Siempre inicializa las variables:

<?php
$auth = false;
if (authUser($_POST["login"], $_POST["password"])) {
    $auth = true;
}
?>

Ahora $auth contiene algo (o nada) entonces siempre resolverá a FALSE. Es una buena idea inicializar las variables incondicionalmente. El siguiente código debería funcionar aunque no es tan robusto:

<?php
if (authUser($_POST["login"], $_POST["password"])) {
    $auth = true;
} else {
    $auth = false;
}
?>

Ahora consideremos que a alguien le gusta revisar las direcciones IP y lo hace de este modo:

<?php
if ($_SERVER["REMOTE_ADDR"] == "127.0.0.1") {
    if (authUser($_POST["login"], $_POST["password"])) {
        $auth = true;
    }
} else {
    $auth = false;
}
?>

La variable $auth puede ser engañada de nuevo !

Nota: El atacante debe conocer la variable a engañar, bien puede adivinarla, obtenerla de algún mensaje de error, usando fuerza bruta o en la mayoría de los casos, se ha hecho con el código fuente (aplicaciones open source o siendo un ex-empleado de una empresa).

Deshabilitando register_globals

Es importante mencionar que deshabilitar register_globals no es en definitiva una defensa contra este tipo de ataques. Esto sólo nos acerca a evitar el más común de los tipos de ataque. Por supuesto es una buena idea deshabilitarlo pero las buenas aplicaciones no dependen de esta directiva y funcionan indistintamente de ellas, así no es necesario emular de este modo:

<?php
// NUNCA USES ESTE TIPO DE CÓDIGO
if (ini_get("register_globals")) {
    foreach ($_REQUEST as $key => $val) {
        unset($$key);
    }
}
?>

Reconociendo variables no inicializadas

PHP posee un mecanismo para vigilar variables no inicializadas, este es el manejador de errores E_NOTICE quien nos muestra las variables no inicializadas, aunque esto conlleva algunos problemas:

1. No advierte acerca de un array sin inicializar.
2. Advierte al acceder a un índice no-existente en un array debidamente inicializado.
3. Se publica en tiempo de ejecución.

E_NOTICE No advierte acerca de un array sin inicializar.

Este primer problema es el más relevante, considere el siguiente código:

<?php
$config["password"] = "pwd";
if (isset($_POST["password"]) && $_POST["password"] == $config["password"]) {
    echo "Secret information.\n";
}
?>

Esto no notará si un atacante falsifica la variable $config. Si el pasa una cadena entones el código es interpretado como esto:

<?php
$config[0] = "p";
// $config es una cadena de modo que  [] es usada para acceder a los bytes de la cadena
// "password" es convertido al número 0 porque la posición de la cadena son siempre enteros
// sólo un byte puede ser escrito a [0] de modo que "pwd" es interpretado como "p"
if (isset($_POST["password"]) && $_POST["password"] == $config[0]) {
    echo "Secret information.\n";
}
?>

Ahora bien, esto es suficiente para adivinar el primer carácter de la contraseña y enviarla junto con el falso $config

E_NOTICE advierte al acceder a un índice no-existente en un array debidamente inicializado.

Este segundo problema no está relacionado con la seguridad pero si con desarrollar código “bien hecho”. El siguiente código informaría una notificación aún si funciona bien y no puede ser engañado:

<input name="search" value="<?php echo htmlspecialchars((string) $_GET["search"]); ?>" />

Con el E_NOTICE habilitado, nosotros debemos re-escribir el código aunque un poco más largo con la misma funcionalidad:

<input name="search" value="<?php
if (isset($_GET["search"])) {
    echo htmlspecialchars((string) $_GET["search"]);
}
?>" />

Otro ejemplo de esta restricción – El siguiente código es perfectamente válido y hace lo que esperamos que haga (contar miembros de un grupo):

<?php
$groups = array();
foreach (getData() as $data) {
    $groups[$data["id_group"]]++;
}
?>

Con el E_NOTICE habilitado, debemos re-escribirlo de este modo:

<?php
$groups = array();
foreach (getData() as $data) {
    if (!isset($groups[$data["id_group"]])) {
        $groups[$data["id_group"]] = 0;
    } else {
        $groups[$data["id_group"]]++;
    }
}
?>

Yo no diría que este es el código más claro y menos propenso a errores (ya hay un error incluido).

E_NOTICE se publica en tiempo de ejecución.

Este tercer problema está relacionado con la seguridad. Si usamos variables no inicializadas que no monitorizamos durante el desarrollo, entonces el atacante puede usarle. Es bueno informar sobre variables no inicializadas en el log de errores pero si esto puede ser usado por el atacante, entonces será demasiado tarde. Es posible hacer notificaciones fatales con set_error_handler pero no vale la pena para la mayoría de las aplicaciones.

Mejor monitoreo de variables no inicializadas

No recomendaría deshabilitar las notificaciones. Sin embargo, esto no soluciona todos los problemas y requiere de re-escribir un código más profundo como han notado. Afortunadamente, hay una forma mejor de rastrear las variables no inicializadas que resuelve los tres problemas de las notificaciones. Su nombre es php-initialized. Es una herramienta para analizar el código fuente en búsqueda de variables no inicializadas. Esto no ejecuta el código y tiene algunas limitaciones pero se puede utilizar para comprobar el código de forma rutinaria, por ejemplo, después o antes de realizar una refactorización.

La principal limitación es que sólo el bloque actual es considerado dentro del ámbito de variables. Así, el siguiente código reclamaría a $auth como variable no inicializada:

<?php
if (authUser($_POST["login"], $_POST["login"])) {
    $auth = true;
} else {
    $auth = false;
}
if ($auth) {
    echo "Secret\n";
}
// Imprime: Uninitialized variable $auth on line 7
?>

No use $_REQUEST

Engañar variables no sólo involucra a las variables globales. La variable $_REQUEST puede ser llenada desde cualquier fuente externa.

Recordemos que $_REQUEST obtiene sus valores de los métodos: POST, GET y COOKIE … en su lugar deberíamos ser más específicos respecto al origen de la información usando las super-globales: $_POST, $_GET y $_COOKIE en cada caso.

En resumen

Las buenas aplicaciones PHP deberían siempre inicializar sus variables antes de usarlas. Es una maravillosa idea establecer el register_globals en OFF Aunque una buena aplicación debe funcionar indistintamente de dicha directiva. PHP nos ofrece un manejador de errores E_NOTICE que puede monitorizar las variables que no están inicializadas pero esto no debe ser 100% confiable. La herramienta php-initialized resolverá estás deficiencias.

En realidad no se trata de un error en sí, sino de una buena practica de programación que evita disparar comportamientos indeseados cuando la aplicación tiene a crecer.

La premisa es simple: no debes asignar variables dentro de una condición.

El típico ejemplo mal indebidamente hecho:

while($array = mysql_fetch_array($result)){

¿Y como debería ser?

while( ($array = mysql_fetch_array($result)) !== false){

¿Cual es la diferencia?

Esta buena práctica evita errores como:

if($a = 36){

Fíjense como sucede una “asignación dentro de una condición“, exactamente lo que debemos evitar… y es malo porque esa asignación SIEMPRE será cierta (true).

¿Y porqué usar !== en lugar de un simple !=?

Ese es otro detallito que muchos suelen ignorar ;-), resulta que esperamos un FALSE booleano, no una “false” cualquiera, así que para estar seguros del valor y el tipo (no vaya a ser un string con la palabra false), lo mejor es comprobar si el dato es IDÉNTICO o NO IDÉNTICO, los cuales evalúan no sólo el contenido de la variable, sino el tipo de variable también.

Espero les haya gustado esta mini-entrada, tenía tiempo sin redactar algo a este abandonado blog. Hasta la próxima.

curl -u USUARIO:PASSWORD -d status="AQUÍ TU MENSAJE" http://api.twitter.com/1/statuses/update.json

Les presento mi primer artículo: UML: Diagramas de flujo para el desarrollo de una plataforma a gran escala

Espero les guste.

No hago copy-paste del mismo para no cometer el error del DRY (Don’t Repeat Yourself )

Como no somos egoístas, compartimos este simple script con el resto de la comunidad y ¿porqué no?, hasta la competencia podría aprender algo más de nosotros !

<?php
/* modifica estos valores según tu servidor.*/
$host="localhost";
$usuario="admin"; //Tu super usuario
$pasword="xxxxx"; //La clave del super-usuario

/*no modifiques nada más*/
$link=mysql_connect($host,$usuario,$pasword);

$dbs=mysql_list_dbs($link);
while ($db=mysql_fetch_object($dbs))
{
        echo "$db->Database\n";
        $tablas = mysql_db_query($db->Database, "SHOW TABLES", $link);
        while ($tabla=mysql_fetch_array($tablas)) {
                mysql_db_query($db->Database, "OPTIMIZE TABLE ".$tabla[0], $link);
                echo "$tabla[0]\n";
        }
}
?>

Sólo resta programar este script con CRON para que se ejecute cada X tiempo (recomendado 1 vez a la semana) y listo !