Scripts de seguridad en Perl

Tutorial I presented at Computer Security conference 2000, giving many examples of small Perl scripts that can help improve security at a site.

1. Introducción

¿Y quién es el tal Gunnar?

  • Administrador de sistemas en la ENEP Iztacala
    • Si bien sé algo de programación, disto mucho de ser programador
  • Miembro externo del DSC
  • Administrador de sistemas desde 1993
  • Paranóico - La paranoia es úncamente la realidad vista a mayor resolución<

¿Y qué es Perl?

Un maravilloso y últimamente muy popular lenguaje de programación de todo propósito, fácilmente extensible.
El lenguaje está diseñado particularmente para buena parte de las necesidades que como administradores de sistemas podemos requerir: Procesar grandes cantidades de datos, buscar patrones en grandes cantidades de datos, manejar conexiones de red, etc.

Acerca de la licencia del código

Todo el código que encuentres aquí está disponible bajo la Licencia Pública de GNU (GPL) versión 2 o posterior, a elección del usuario.
La licencia GPL estipula que el código puede ser libremente distribuído, leído, modificado y redistribuído, incluído en otros proyectos, tomar fragmentos, o utilizado en cualquier manera, siempre y cuando éste y todo código derivado de él sean siempre distribuídos bajo la licencia GPL.
Para mayor información acerca de las licencias libres (copyleft y no copyleft) y no libres, aquí hay una interesante exposición.

¿Y por qué en inglés?

No, no es porque me guste el inglés. No hago esto por facilitarme el copiar ejemplos de un libro ni por pocho.
Creo que alguno de estos scripts será útil cuando menos a una persona que no sea hispanoparlante. Espero que así sea. Entre los hispanoparlantes con nivel técnico medio o elevado es mucho más
frecuente el dominio del inglés que en el caso contrario.
Espero que esta decisión mía no ofenda a ninguno de ustedes.

Formato del tutorial

En este tutorial analizaremos varios scripts de Perl de diferentes grados de complejidad. Dada la naturaleza de éste medio, no reproduciré los scripts en la presentación, sino que daré un esbozo estructural y daré ligas a páginas donde éstos estén disponibles.
Los scripts no están preparados, procesados y listos, sino que son muestras de diferentes técnicas que ustedes podrán utilizar en sus programas, o primeros esbozos de programas que requieren ser
perfeccionados para utilizarse en ambientes de producción.

2. Analizando datos

Expiración

En un servidor con más de cien cuentas se puede volver imposible llevar a mano el registro de qué cuentas están activas, qué cuentas ya expiraron y hace cuánto tiempo. Este sencillo script de menos de 70 líneas puede generar un reporte periódico al administrador del estado de las cuentas en su sistema.
Por simplicidad, el script está construído alrededor de la estructura fija del archivo /etc/shadow. Transportarlo a otros sistemas, sin embargo, debe ser trivial.

Consideraciones de seguridad

Estamos ante uno de los mayores riesgos de seguridad: un programa que debe correr con privilegio de root, el único usuario con derecho de leer el archivo /etc/shadow. Es muy importante tomar todas las precauciones; el script corre con use strict y en modo -Tw (tainted y warnings). Fuera de la lectura inicial no tiene ninguna interacción con el mundo; la salida la envía a STDOUT. Esto es para evitar que alguien se aproveche de sus elevados atributos para atacar al sistema.
Este script está pensado para correr desde el crontab de root.

Funcionamiento general

El funcionamiento de este script es muy sencillo. Tras cargar el módulo Date::Calc y activar el pragma strict, iteramos sobre cada línea del archivo /etc/shadow, revisando su octavo campo (recuerden que el número base de un arreglo es 0), acomodándolo acorde a su estado respecto a la fecha actual en uno de cinco arreglos.Posteriormente, por medio de otra muy simple rutina, imprime cada uno de estos arreglos en órden. El programa nos reportará en este órden las cuentas próximas a expirar o recién expiradas, las que expiraron en el último mes, las que llevan ya más de un mes expiradas, las que no han expirado y las que no tienen fecha de expiración.

Funcionamiento: Obtención y comparación de la fecha

En la línea 12 vemos que:

  1. $dias=Delta_Days(1970,1,1,@fecha);

En los sistemas Unix, las fechas se guardan como el número de días transcurridos desde el 1 de enero de 1970. Las fechas de expiración en
/etc/shadow están en este mismo formato, por lo cual compararlas posteriormente será únicamente comparar dos valores numéricos.

Funcionamiento: Generación del reporte

Al poblar los cinco arreglos pueden haber notado que lo hacemos con una referencia a un arreglo [$login,$dias]. Esto es para pasar dos datos en una sola variable escalar.
Al recibir estos datos en &reporta los separamos expresamente en $login y $dias para evitar que los datos nos lleguen en un formato no
previsto y afecten de alguna manera la ejecución y seguridad de nuestro programa.

  1. #!/usr/bin/perl -Tw
  2. # expira.pl
  3. #
  4. # Reporta las fechas de expiracion de las cuentas de los usuarios
  5. #
  6. use strict;
  7. use Date::Calc qw(Today Delta_Days);
  8. my ($dias,@fecha,$file,@linea,@nuncaExpira,@expiraPronto,@expiraMes,@expiraAntes,@noExpirada);
  9. @fecha=Today;
  10. $dias=Delta_Days(1970,1,1,@fecha);
  11. $file='/etc/shadow';
  12. # Solo root puede abrir el archivo /etc/shadow
  13. open(FILE,$file) or die 'Es necesario ejecutar este script como root';
  14. while (@linea=split(/:/,&lt;FILE&gt;)) {
  15. if ($linea[7] eq '' || $linea[7] &lt; 0) {
  16. # La cuenta no expira
  17. push (@nuncaExpira,[$linea[0],$linea[7]]);
  18. } elsif (($linea[7]-5)&lt;$dias &amp;&amp; ($linea[7]+5)&gt;$dias) {
  19. # La cuenta expira o expiro en estos dias
  20. push (@expiraPronto,[$linea[0],$linea[7]]);
  21. } elsif ($linea[7]+30&gt;=$dias &amp;&amp; $linea[7]&lt;$dias) {
  22. # La cuenta expiro hace menos de 30 dias
  23. push (@expiraMes,[$linea[0],$linea[7]]);
  24. } elsif ($linea[7]&lt;$dias) {
  25. # La cuenta expiro hace mas de un mes
  26. push (@expiraAntes,[$linea[0],$linea[7]]);
  27. } else {
  28. # La cuenta no ha expirado
  29. push (@noExpirada,[$linea[0],$linea[7]]);
  30. }
  31. }
  32. close(FILE);
  33. print &quot;\n&quot;;
  34. print '='x37,&quot;\n  Cuentas que expiran en estos dias  \n&quot;,'='x37,&quot;\n&quot;;
  35. &amp;reporta(\@expiraPronto);
  36. print '='x37,&quot;\n Cuentas que expiraron el ultimo mes \n&quot;,'='x37,&quot;\n&quot;;
  37. &amp;reporta(\@expiraMes);
  38. print '='x37,&quot;\n  Cuentas que expiraron hace tiempo  \n&quot;,'='x37,&quot;\n&quot;;
  39. &amp;reporta(\@expiraAntes);
  40. print '='x37,&quot;\n     Cuentas que no han expirado     \n&quot;,'='x37,&quot;\n&quot;;
  41. &amp;reporta(\@noExpirada);
  42. print '='x37,&quot;\n        Cuentas que no expiran       \n&quot;,'='x37,&quot;\n&quot;;
  43. &amp;reporta(\@nuncaExpira);
  44. sub reporta {
  45. my ($login,$dias);
  46. foreach (@{$_[0]}) {
  47. ($login,$dias)=@{$_};
  48. printf(&quot;   %-15s %6s\n&quot;,$login,$dias);
  49. }
  50. }

Atributos

Es muy importante mantener verificada la integridad de nuestro sistema. Si no llevamos registro de los cambios efectuados a nuestros equipos, un atacante podrá entrar y modificar nuestro sistema sin ninguna dificultad, y será imposible determinar el alcance de los daños provocados por él.
Hay varios paquetes que hacen algo parecido a este script, el más conocido de ellos Tripwire. Todos ellos, sin embargo, pueden ser perfeccionados de más de una manera. Ilustramos aquí el funcionamiento del módulo central.

Dos versiones - El dilema de la firma

Presentamos dos versiones del programa - una que revisa únicamente los atributos de los archivos y una que calcula las firmas MD5 de cada
uno de ellos. ¿Por qué?

  • Seguridad- Si firmamos cada archivo, nos es necesario poder leer cada uno de ellos. Muchos archivos claves del sistema requieren tener root para leerlos. Si buscamos que un usuario cualquiera ejecute el programa, sólo podremos revisar los atributos.
  • Velocidad- Calcular la firma MD5 de un par de archivos es muy rápido. Sin embargo, calcular la de cientos o miles de archivos puede tomar mucho más tiempo del que estamos dispuestos a invertir. Cada usuario deberá poder elegir lo que juzgue mejor.

Consideraciones de seguridad

Aparte del punto de seguridad antes mencionado, nuestro programa debe poder listar todos los directorios a los que entre, ya que de ellos sacará la información necesaria. Si tenemos directorios protegidos con permisos 700, por ejemplo, nuestro programa no podrá entrar a este a menos que corra como el dueño del directorio.
Si decidimos no correr la versión MD5 del programa, un atacante con cierto conocimiento del sistema puede sin ningún problema alterar los
datos para cubrir sus huellas. Esta es una protección contra cambios no deseados y contra script kiddies.

Funcionamiento general

El programa revisa primero que nada si fue llamado en modo de creación de la base de datos o de revisión del sistema. En el primer caso, es llamado para únicamente procesar un archivo. La operación es muy sencilla - Imprime una línea con las características que stat arroja sobre el archivo. Esta línea la podemos guardar en nuestra base de datos.
Al verificar archivos, el programa itera sobre el archivo con los datos y, si hay alguna discrepancia con el estado actual, lo reporta de
una manera fácil de leer y comprender.

Funcionamiento general: Ejemplo de salida

  1. [gwolf@server gwolf]$ ./atributos.pl -p /home/gwolf/archivo_prueba.txt
  2. /home/gwolf/archivo_prueba.txt|1811|246064|33188|2|1160|0|1035916|2543|973982482|973982482|8192|6
  3. [gwolf@server gwolf]$ ./atributos.pl -p /home/gwolf/archivo_prueba.txt &gt; database.ck
  4. [gwolf@server gwolf]$ ./atributos.pl -c database.ck 
  5. [gwolf@server gwolf]$ echo 'modificando' &gt;&gt; archivo_prueba.txt
  6. [gwolf@server gwolf]$ ./atributos.pl -c database.ck 
  7. /home/gwolf/archivo_prueba.txt:
  8. size is now 2918 (should be 2907)
  9. mtime is now 973982824 (should be 973982482)
  10. ctime is now 973982824 (should be 973982482)

Funcionamiento: Procesando opciones

En el script utilizamos el módulo Getopt::Std. Con él, las opciones de línea de comando que son especificadas con el comando

  1. getopt('p:c:');</code
  2. son recibidas en las variables <code>$opt_p
y $opt_c.

Funcionamiento: stat

Para conseguir los atributos de un archivo, no hay nada más útil que stat. Esta función nos regresa el siguiente arreglo:

  • dev Dispositivo físico
  • ino Número de i-nodo
  • mode Tipo y permisos del archivo
  • nlink Número de ligas duras
  • uid UID
  • gid GID
  • rdev Identificador de dispositivo (archivos especiales)
  • size Longitud total
  • atime Último acceso (formato epoch)
  • mtime Última modificación (formato epoch)
  • ctime Tiempo de modificación del inodo (formato epoch)
  • blksize Tamaño de bloques preferido para el sistema de archivos
  • blocks Número de bloques utilizados

  1. #!/usr/bin/perl -Tw
  2. use Getopt::Std;
  3. # We use this for prettier output later in &amp;printchanged()
  4. @statnames = qw(dev ino mode nlink uid gid rdev size mtime ctime blksize blocks);
  5. getopt('p:c:');
  6. die &quot;Usage: $0 [-p &lt;filename&gt;|-c &lt;filename&gt;]\n&quot; unless ($opt_p or $opt_c);
  7. if ($opt_p) {
  8. die &quot;Unable to stat file $opt_p: $!\n&quot; unless (-e $opt_p);
  9. print $opt_p,&quot;|&quot;,join('|',(lstat($opt_p))[0..7,9..12]),&quot;\n&quot;;
  10. exit;
  11. }
  12. if ($opt_c) {
  13. open(CFILE,$opt_c) or die &quot;Unable to open check file $opt_c: $!\n&quot;;
  14. while (&lt;CFILE&gt;){
  15. chomp;
  16. @savedstats = split('\|');
  17. die &quot;Wrong number of fields in line beginning with $savedstats[0]&quot; unless ($#savedstats == 12);
  18. @currentstats = (lstat($savedstats[0]))[0..7,9..12];
  19. # print the changed fields only if something has changed
  20. &amp;printchanged(\@savedstats,\@currentstats) if (&quot;@savedstats[1..12]&quot; ne &quot;@currentstats&quot;);
  21. }
  22. close(CFILE);
  23. }
  24. # iterates through attributes lists and prints any changes between
  25. # the two
  26. sub printchanged{
  27. my ($saved,$current) = @_;
  28. # print the name of the file after popping it off of the array read
  29. # from the check file
  30. print shift @{$saved},&quot;:\n&quot;;
  31. for (my $i = 0 ; $i &lt; $#{$saved} ; $i++) {
  32. if ($saved-&gt;[$i] ne $current-&gt;[$i]) {
  33. print &quot;\t&quot;.$statnames[$i].&quot; is now &quot;.$current-&gt;[$i];
  34. print &quot; (should be &quot;.$saved-&gt;[$i].&quot;)\n&quot;;
  35. }
  36. }
  37. }

Atributos y MD5

Es muy importante mantener verificada la integridad de nuestro sistema. Si no llevamos registro de los cambios efectuados a nuestros equipos, un atacante podrá entrar y modificar nuestro sistema sin ninguna dificultad, y será imposible determinar el alcance de los daños provocados por él.
Hay varios paquetes que hacen algo parecido a este script, el más conocido de ellos Tripwire. Todos ellos, sin embargo, pueden ser perfeccionados de más de una manera. Ilustramos aquí el funcionamiento del módulo central.

Dos versiones - El dilema de la firma

Presentamos dos versiones del programa - una que revisa únicamente los atributos de los archivos y una que calcula las firmas MD5 de cada
uno de ellos. ¿Por qué?

  • Seguridad- Si firmamos cada archivo, nos es necesario poder leer cada uno de ellos. Muchos archivos claves del sistema requieren tener root para leerlos. Si buscamos que un usuario cualquiera ejecute el programa, sólo podremos revisar los atributos.
  • Velocidad- Calcular la firma MD5 de un par de archivos es muy rápido. Sin embargo, calcular la de cientos o miles de archivos puede tomar mucho más tiempo del que estamos dispuestos a invertir. Cada usuario deberá poder elegir lo que juzgue mejor.

Consideraciones de seguridad

Aparte del punto de seguridad antes mencionado, nuestro programa debe poder listar todos los directorios a los que entre, ya que de ellos sacará la información necesaria. Si tenemos directorios protegidos con permisos 700, por ejemplo, nuestro programa no podrá entrar a este a menos que corra como el dueño del directorio.
Si decidimos no correr la versión MD5 del programa, un atacante con cierto conocimiento del sistema puede sin ningún problema alterar los
datos para cubrir sus huellas. Esta es una protección contra cambios no deseados y contra script kiddies.

Funcionamiento general

El programa revisa primero que nada si fue llamado en modo de creación de la base de datos o de revisión del sistema. En el primer caso, es llamado para únicamente procesar un archivo. La operación es muy sencilla - Imprime una línea con las características que stat arroja sobre el archivo. Esta línea la podemos guardar en nuestra base de datos.
Al verificar archivos, el programa itera sobre el archivo con los datos y, si hay alguna discrepancia con el estado actual, lo reporta de
una manera fácil de leer y comprender.

Funcionamiento general: Ejemplo de salida

  1. [gwolf@server gwolf]$ ./atributos.pl -p /home/gwolf/archivo_prueba.txt
  2. /home/gwolf/archivo_prueba.txt|1811|246064|33188|2|1160|0|1035916|2543|973982482|973982482|8192|6
  3. [gwolf@server gwolf]$ ./atributos.pl -p /home/gwolf/archivo_prueba.txt &gt; database.ck
  4. [gwolf@server gwolf]$ ./atributos.pl -c database.ck 
  5. [gwolf@server gwolf]$ echo 'modificando' &gt;&gt; archivo_prueba.txt
  6. [gwolf@server gwolf]$ ./atributos.pl -c database.ck 
  7. /home/gwolf/archivo_prueba.txt:
  8. size is now 2918 (should be 2907)
  9. mtime is now 973982824 (should be 973982482)
  10. ctime is now 973982824 (should be 973982482)

Funcionamiento: Procesando opciones

En el script utilizamos el módulo Getopt::Std. Con él, las opciones de línea de comando que son especificadas con el comando
getopt('p:c:');
son recibidas en las variables $opt_p y $opt_c.

Funcionamiento: stat

Para conseguir los atributos de un archivo, no hay nada más útil que stat. Esta función nos regresa el siguiente arreglo:

  • dev Dispositivo físico
  • ino Número de i-nodo
  • mode Tipo y permisos del archivo
  • nlink Número de ligas duras
  • uid UID
  • gid GID
  • rdev Identificador de dispositivo (archivos especiales)
  • size Longitud total
  • atime Último acceso (formato epoch)
  • mtime Última modificación (formato epoch)
  • ctime Tiempo de modificación del inodo (formato epoch)
  • blksize Tamaño de bloques preferido para el sistema de archivos
  • blocks Número de bloques utilizados

  1. #!/usr/bin/perl -Tw
  2. use Getopt::Std;
  3. use Digest::MD5 qw(md5);
  4. # We use this for prettier output later in &amp;printchanged()
  5. @statnames = qw(dev ino mode nlink uid gid rdev size mtime ctime blksize blocks md5);
  6. getopt('p:c:');
  7. die &quot;Usage: $0 [-p &lt;filename&gt;|-c &lt;filename&gt;]\n&quot; unless ($opt_p or $opt_c);
  8. if ($opt_p) {
  9. die &quot;Unable to stat file $opt_p: $!\n&quot; unless (-e $opt_p);
  10. open(F,$opt_p) or die &quot;Unable to open $opt_p: $!\n&quot;;
  11. $digest = Digest::MD5-&gt;new-&gt;addfile(F)-&gt;hexdigest;
  12. close(F);
  13. print $opt_p,&quot;|&quot;,join('|',(lstat($opt_p))[0..7,9..12]),&quot;|$digest\n&quot;;
  14. exit;
  15. }
  16. if ($opt_c) {
  17. open(CFILE,$opt_c) or die &quot;Unable to open check file $opt_c: $!\n&quot;;
  18. while (&lt;CFILE&gt;){
  19. chomp;
  20. @savedstats = split('\|');
  21. die &quot;Wrong number of fields in line beginning with $savedstats[0]&quot; unless ($#savedstats == 13);
  22. @currentstats = (lstat($savedstats[0]))[0..7,9..12];
  23. open(F,$savedstats[0]) or die &quot;Unable to open $opt_c: $!\n&quot;;
  24. push(@currentstats,Digest::MD5-&gt;new-&gt;addfile(F)-&gt;hexdigest);
  25. close(F);
  26. # print the changed fields only if something has changed
  27. &amp;printchanged(\@savedstats,\@currentstats) if (&quot;@savedstats[1..13]&quot; ne &quot;@currentstats&quot;);
  28. }
  29. close(CFILE);
  30. }
  31. # iterates through attributes lists and prints any changes between
  32. # the two
  33. sub printchanged{
  34. my ($saved,$current) = @_;
  35. # print the name of the file after popping it off of the array read
  36. # from the check file
  37. print shift @{$saved},&quot;:\n&quot;;
  38. for (my $i = 0 ; $i &lt; $#{$saved} ; $i++) {
  39. if ($saved-&gt;[$i] ne $current-&gt;[$i]) {
  40. print &quot;\t&quot;.$statnames[$i].&quot; is now &quot;.$current-&gt;[$i];
  41. print &quot; (should be &quot;.$saved-&gt;[$i].&quot;)\n&quot;;
  42. }
  43. }
  44. }

3. Búsqueda de patrones

Bitácoras - Uso del sistema

Es muy importante para un administrador de sistemas analizar los datos generados por las bitácoras de su sistema. De ellas podemos, entre otras cosas, sacar posibles errores que estemos cometiendo con nuestra configuración del sistema o encontrar posibles intentos de intrusión. Desafortunadamente, leer bitácoras puede ser tedioso.
Presento aquí un script que analiza la salida de last buscando cuántas veces se ha conectado un usuario y por cuánto tiempo en el último mes.

Consideraciones de seguridad

Las bitácoras del sistema típicamente seran legibles únicamente para root. En este caso decidí utilizar un programa que funciona en el espacio de usuario y nos presenta la bitácora binaria wtmp para evitar hacer otra demostración que requiera correr como superusuario.

Funcionamiento general

El programa itera sobre cada línea resultante de correr el programa indicado en $lastProg, ignorando las líneas que no van asociadas a un login verdadero. Utilizando el hash %usedTime registra en una sencilla estructura cuántas veces entró un usuario, y por cuánto tiempo lo hizo. Por último, nos lo reporta utilizando un formato de printf.

Funcionamiento: Sumando minutos y horas

En la función toMinutes primero que nada verificamos que el formato de la hora sea el correcto: Dos dígitos representando la hora y otros dos representando los minutos, separados por dos puntos. Nos es más fácil guardar un valor fácil de sumar, como lo son los minutos, por lo que multiplicamos las horas por 60 y sumamos el resultado a los minutos. Sumamos esto al valor ya existente en $usedTime{$user}[0].

Funcionamiento: Separando horas de minutos por el camino fácil

Al principio del programa tenemos la directiva use integer;. Esta indica al compilador que use aritmética entera, en vez de trabajar con puntos flotantes, el comportamiento normal de Perl. Esto, además de darnos un poco de velocidad al hacer operaciones, nos permite dar menos rodeos en la función printResults. Para separar horas y minutos basta con que dividamos los minutos entre 60 - El entero resultante son las horas, el residuo los minutos, y no tendremos que pelearnos con fracciones decimales.

  1. #!/usr/bin/perl -w
  2. use integer;
  3. use strict;
  4. my (%usedTime, $lastProg);
  5. $lastProg = '/usr/bin/last';
  6. foreach my $line (`$lastProg`) {
  7. next if ($line =~ /^(reboot|ftp|wtmp begins)/ || $line =~ /^\s*$/);
  8. $line =~ s/\s+$//g;
  9. my $user = substr($line,0,10);
  10. $user =~ s/\s.+//g;
  11. my $time = &amp;toMinutes(substr($line,length($line)-6,5));
  12. $usedTime{$user} = [0,0] unless defined($usedTime{$user});
  13. $usedTime{$user}[0] += $time;
  14. $usedTime{$user}[1] += 1;
  15. }
  16. &amp;printResults(\%usedTime);
  17. exit 0;
  18. sub toMinutes {
  19. my ($in,$hr,$min);
  20. $in = shift;
  21. return 0 unless ($in =~ /^\d\d\:\d\d$/);
  22. $hr = substr($in,0,2);
  23. $min = substr($in,3,2);
  24. return ($hr*60+$min);
  25. }
  26. sub printResults {
  27. my ($totMin,$hr,$min,$numLogins);
  28. print &quot;Login      Time used  Logins\n&quot;;
  29. print &quot;============================\n&quot;;
  30. foreach my $user (sort(keys(%usedTime))) {
  31. $totMin=$usedTime{$user}[0];
  32. $numLogins=$usedTime{$user}[1];
  33. $hr=$totMin / 60;
  34. $min=$totMin % 60;
  35. printf(&quot;%-10s %02s:%02s      %-2s\n&quot;,$user,$hr,$min,$numLogins);
  36. }
  37. }

Bitácoras - Errores del servidor HTTP

Muchos programas analizan, de alguna u otra manera, el contenido de las bitácoras del sistema (como ejemplos, Logcheck (tutorial en español disponible aquí) y Swatch). Hay programas también dedicados a monitorear y reaccionar en tiempo real a los errores producidos por Apache, como el Apache Guardian.
Sin embargo, un programa que recorra un archivo de bitácora de Apache y reporte, de una manera limpia y fácil de entender los errores ocurridos tenía que ser ideado a mano por los administradores. Es eso lo que intento aquí cubrir.

Consideraciones de seguridad

Este script debe correr con un usuario que tenga derecho de ver el archivo de bitácoras de Apache, típicamente localizado en /var/www/logs/error_log/var/log/httpd/error_log. Para evitar que este script requiera privilegios de root para correr, sugiero que dicho archivo pertenezca a un grupo de administración (daemon o wheel, por ejemplo), permitiendo a dicho grupo acceso únicamente de lectura, de la siguiente manera:
-rw-r-----  1 root  daemon  2188152 Dec  7 10:03 /var/www/logs/error_log

Funcionamiento general

El script procesa una tras otra todas las líneas del archivo indicado en la variable $file. Reporta un resúmen de lo que encuentre en dicho archivo con el siguiente formato:

  1. Directory index forbidden by rule
  2. 1                          
  3. 1 /var/www/htdocs/comun/
  4. 7 /var/www/htdocs/data/Icons/
  5. 2 /var/www/htdocs/images/
  6. File does not exist
  7. 1                          
  8. 5 /var/www/htdocs/biblio/
  9. 2 /var/www/htdocs/CURSO
  10. 1 /var/www/htdocs/adm_list/approve.cgi
  11. (...)

Funcionamiento: Organizando los datos

El formato de las bitácoras de error de Apache es el siguiente:
[<i>fecha</i>] [<i>categoría</i>] [client <i>w.x.y.z</i>] <i>tipo de error</i>: <i>archivo que lo ocasionó</i>
por ejemplo,
[Thu Dec  7 10:03:27 2000] [error] [client 192.168.2.45] File does not exist: /var/www/htdocs/esta/pagina/no/existe
Lo dividimos, entonces, utilizando el caracter ] como separador de campo. Descartamos todas las líneas que no lleven error como categoría, y de las líneas que nos interesen, el último campo lo dividimos en tipo de error y archivo que lo ocasiona utilizando el
caracter :.
En el hash %errores guardamos los datos resultantes, utilizando como llave el tipo de error, y agregando el archivo que lo ocasionó a la lista guardada por referencia relacionada a esa llave.

Funcionamiento: Reportando

Al reportar, recorremos los tipos de error y, para cada uno de ellos, recorremos el arreglo, guardando ahora en el hash %sumado como llave el nombre de cada uno de los causantes de error, y sumándole uno al valor de esta llave cada que lo encontremos. Una vez procesado el arreglo completo, reportamos primero el tipo de error, y después (indentando por claridad) cada uno de los archivos que lo ocasionaron, con el número de veces que fue llamado.

  1. #!/usr/bin/perl -Tw
  2. use integer;
  3. use strict;
  4. my (%errores, $file);
  5. $file = '/var/www/logs/error_log';
  6. open(IN,&quot;&lt;$file&quot;) or die &quot;Could not open $file - $@ $!&quot;;
  7. foreach my $line (&lt;IN&gt;) {
  8. chomp($line);
  9. my (@datos,@detalles);
  10. @datos = split(/\]/,$line);
  11. next if ($datos[1] ne ' [error');
  12. @detalles = split(/: /,$datos[3]);
  13. $errores{$detalles[0]} = [] if (not defined $errores{$detalles[0]});
  14. my ($tipoErr,$archErr) = @detalles;
  15. push(@{$errores{$tipoErr}},$archErr);
  16. }
  17. &amp;printResults(\%errores);
  18. sub printResults {
  19. my ($llave,%hash,%sumado);
  20. %hash = %{$_[0]};
  21. foreach $llave (sort(keys(%hash))) {
  22. print &quot;$llave\n&quot;;
  23. while (@{$hash{$llave}}) {
  24. my ($tmp);
  25. $tmp=shift(@{$hash{$llave}});
  26. $sumado{$tmp}++;
  27. }
  28. foreach my $file (sort(keys(%sumado))) {
  29. printf (&quot;     %3d