Cambio de nombre del interfaz de red en GNU/Linux

El otro día la tarjeta de red integrada de la placa base de mi desktop dejó de dar señales de vida, por lo que para seguir conectado, tuve que adquirir una nueva. Tras el cambio y al encender mi sistema, Debian, la tarjeta de red ahora se llamaba eth2. Esto no me suponía ningún tipo de problema, pero la mayor parte del software que empleo, por defecto usa eth0 para operar y si quieres indicar otro interfaz de red, debes indicárselo manualmente (típica opción -i ethX). Como mi tarjeta eth0 estaba 100% muerta y no iba a volver, opté por cambiarle el nombre a eth2 y ponerle el de la anterior, para así tener un sistema sin cambios.
Debian, al igual que la mayoría de los sistemas Linux actuales emplean udev para controlar los dispositivos, por lo que la solución para cambiarle el nombre era ir al fichero de configuración (/etc/udev/rules.d/70-persistent-net.rules) y cambiar el nombre eth0 <-> eth2. Un pequeño cambio que tras un rápido reinicio, me permite volver a disfrutar de eth0 en mi sistema.
shell> ifconfig
eth0      Link encap:Ethernet  HWaddr 00:e0:4c:66:98:20  
          inet addr:192.168.1.33  Bcast:192.168.1.255  Mask:255.255.255.0
          inet6 addr: fe80::2e0:4cff:fe66:9820/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:157686 errors:0 dropped:0 overruns:0 frame:0
          TX packets:163422 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:93148464 (88.8 MiB)  TX bytes:35958264 (34.2 MiB)
          Interrupt:20 Base address:0x2000 

lo        Link encap:Local Loopback  
          inet addr:127.0.0.1  Mask:255.0.0.0
          inet6 addr: ::1/128 Scope:Host
          UP LOOPBACK RUNNING  MTU:16436  Metric:1
          RX packets:110 errors:0 dropped:0 overruns:0 frame:0
          TX packets:110 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0 
          RX bytes:11731 (11.4 KiB)  TX bytes:11731 (11.4 KiB)

Leer más

Linux benchmark II

Dentro de la serie de artículos relacionados con el benchmarcking de sistemas GNU/Linux, hoy vamos a ver cómo comprobar el rendimiento de una base de datos MySQL. Para hacerlo vamos a emplear el comando que introdujimos en el primer post, sysbench. Gracias a él, vamos a simular un número muy elevado de conexiones a MySQL y ejecutar una serie de sentencias, sacando un informe final de rendimiento.
Puesto que cuando evaluamos una base de datos, no siempre es necesario escribir en ella, sysbench lo tiene en cuenta y permite optar por hacer los test en RO o en RW. También, y para no alterar el correcto funcionamiento de las bases de datos que ya tenemos funcionando, sysbench creará la suya propia, con los datos adecuados para realizar los tests e introducirá una sería de tuplas aleatorias en ella.
Para comenzar, por lo tanto, vamos a preparar nuestro entorno de pruebas. Lo único que necesitaremos será una base de datos MySQL a la que poder conectarnos.

Preparando datos

Vamos a crear una tabla temporal dentro de la base de datos test, que tenga 1 millón de filas con las que posteriormente operar.
shell> sysbench --test=oltp --oltp-table-size=1000000 \
       --mysql-db=test --mysql-user=root --mysql-password=your_passwd \
       prepare
Una vez el comando haya finalizado, vamos a ver qué ha creado. Esto no es para nada necesario, pero así también nos hacemos una idea de qué tipo de datos emplear para los test.
mysql> show create table sbtest;
+--------+----------------------------------------------------+
| Table  | Create Table                                       |
+--------+----------------------------------------------------+
| sbtest | CREATE TABLE `sbtest` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `k` int(10) unsigned NOT NULL DEFAULT '0',
  `c` char(120) NOT NULL DEFAULT '',
  `pad` char(60) NOT NULL DEFAULT '',
  PRIMARY KEY (`id`),
  KEY `k` (`k`)
) ENGINE=InnoDB AUTO_INCREMENT=1000001 DEFAULT CHARSET=latin1 |
+--------+----------------------------------------------------+
1 row in set (0.00 sec)

mysql> select * from sbtest limit 3;
+----+---+---+----------------------------------------------------+
| id | k | c | pad                                                |
+----+---+---+----------------------------------------------------+
|  1 | 0 |   | qqqqqqqqqqwwwwwwwwwweeeeeeeeeerrrrrrrrrrtttttttttt |
|  2 | 0 |   | qqqqqqqqqqwwwwwwwwwweeeeeeeeeerrrrrrrrrrtttttttttt |
|  3 | 0 |   | qqqqqqqqqqwwwwwwwwwweeeeeeeeeerrrrrrrrrrtttttttttt |
+----+---+---+----------------------------------------------------+
3 rows in set (0.00 sec)
Lo que más destaca aquí es el tipo de columnas que emplear. Un par de ellas de tipo int y una autoincremental y otras dos de tipo char.

Realizando comprobaciones

Antes de entrar en este punto sí es bastante importante echar un vistazo al manual de sysbench, pues las diferentes opciones con las que puede trabajar son importantes. Por defecto el tipo de tabla es InnoDB, que en mi caso es correcto por lo que no lo alteraré.
shell> sysbench --test=oltp --oltp-table-size=1000000 \
       --mysql-db=test --mysql-user=root --mysql-password=your_passwd \
       --max-time=60 --oltp-read-only=on --num-threads=8 run
...
OLTP test statistics:
    queries performed:
        read:                            261282
        write:                           0
        other:                           37326
        total:                           298608
    transactions:                        18663  (311.00 per sec.)
    deadlocks:                           0      (0.00 per sec.)
    read/write requests:                 261282 (4353.94 per sec.)
    other operations:                    37326  (621.99 per sec.)
...
Otro ejemplo podría ser,
shell> sysbench --num-threads=16 --max-requests=100000 --test=oltp \
       --mysql-db=test --mysql-user=root --mysql-password=your_passwd \
       --oltp-table-size=1000000 --oltp-read-only=on run
...
transactions:                        100000 (304.29 per sec.)
...
Y otro más,
shell> sysbench --test=oltp \
       --mysql-db=test --mysql-user=root --mysql-password=your_passwd \
       --max-requests=10000 --num-threads=10 run
...
transactions:                        10000  (224.58 per sec.)
...
Como podemos observar, según las opciones especificadas en el comando, el rendimiento obtenido es diferente, de ahí la importancia de combinar este comando con una buena configuración. Según el objetivo que tengamos (conseguir más lecturas, más escrituras, un término intermedio, etc. tendremos que ir alterando la configuración de MySQL (/etc/my.cfg) y volver a lanzar el test de estrés.
En mi sistemas, como en los vuestros, vemos que el rendimiento de desploma bastante de ejecutar un único thread a varios thread's simultáneamente. Y es justo en estos casos donde debemos de ganar rendimiento!

Borrando tablas temporales

Una vez hayamos finalizamos el test debemos de borrar la tabla temporal que se creó para tal efecto, para que no quede ocupando espacio tontamente en el servidor.
También tras cada ejecución si los datos son alterados, deberíamos de borrar los datos de pruebas y volver a generarlos, para trabajar siempre con la misma batería de pruebas iniciales y que ésto no influya en los resultados.
shell> sysbench --test=oltp \
       --mysql-db=test --mysql-user=root --mysql-password=your_passwd \
       cleanup

La entrada Linux benchmark II la puedes leer en Puppet Linux.
Leer más

Abriendo puertos por combinación

Hace ya unos cuantos días publiqué un post que trataba de cómo activar SSH en dos pasos para aumentar la seguridad de inicio de sesión. Este tipo de seguridad ofrece una capa extra al típico inicio de sesión de login/password, ya que incluye el factor móvil y temporal. Al más puro estilo Gmail en 2 pasos. Pues bien, esta combinación es efectiva, pero nada impide a los bot's que hay por Internet estar intentando averiguar el usuario para acceder. Aunque estemos más seguros de que no lo van a conseguir, miles de intentos diarios nos ensucian los log's y hace que sea difíciles de controlar. Para ello, hoy vamos a ver cómo programar una combinación de puertos secreta que habilite el puerto SSH cuando nosotros lo requiramos y sino que esté cerrado.
La idea general de esto es, enviamos un ping al puerto X, Y y Z del equipo y éste nos abre el puerto 22 y si lo volvemos a hacer, automáticamente lo cierra, empleando iptables para ello. Esta técnica se conoce como port knocking y realmente se podría englobar en seguridad por ofuscación.
Vamos a comenzar por instalar el software necesario, knockd, para luego preparar el sistema.
shell> apt-get install knockd
Ahora vamos a permitir que el software arranque cuando se inicia el equipo. Para ello editamos el fichero de configuración por defecto, /etc/default/knockd (necesario en Debian/Ubuntu).
START_KNOCKD=1
Ya sólo nos queda configurar knockd para establecer la secuencia que apertura y cierre del puerto SSH. Para ello, editamos el fichero de configuración general, /etc/knockd.conf y lo dejamos tal que así.
Personalmente no me gusta dejar la combinación de puertos por defecto, así que las cambiamos. Los puertos elegidos ya quedan a vuestro gusto.
[options]
  UseSyslog

[openSSH]
  sequence    = 7070,8080,9090
  seq_timeout = 5
  command     = /sbin/iptables -A INPUT -s %IP% -p tcp --dport 22 -j DROP
  tcpflags    = syn

[closeSSH]
  sequence    = 9090,8080,7070
  seq_timeout = 5
  command     = /sbin/iptables -D INPUT -s %IP% -p tcp --dport 22 -j DROP
  tcpflags    = syn

Y finalmente arrancamos el nuevo servicio.
shell> /etc/init.d/knockd start
Starting Port-knock daemon: knockd.
Cada vez que deseemos acceder al equipo, simplemente tendremos que emplear nmap antes para habilitar la secuencia mágica de acceso. En nuestro caso,
shell> nmap -sT -p7070,8080,9090 192.168.1.150
Y tras ello, el puerto SSH quedará abierto. Al finalizar el trabajo, lo vamos a dejar cerrado. Para ello,
shell> nmap -sT -p9090,8080,7070 192.168.1.150
Por cierto, del lado del servidor SSH que estamos abriendo veremos el "ábrete sésamo",
knockd: 192.168.1.33: openSSH: Stage 1
knockd: 192.168.1.33: closeSSH: Stage 2
knockd: 192.168.1.33: closeSSH: Stage 3
knockd: 192.168.1.33: closeSSH: OPEN SESAME
knockd: closeSSH: running command: /sbin/iptables -D INPUT -s 192.168.1.33...
Leer más

Linux benchmark I

Hoy vamos a comenzar por una serie de artículos relacionados con los test de estrés a sistemas GNU/Linux. Todos sabemos la importancia de un buen rendimiento de nuestros equipos y mucho mayor la importación de dicho benchmark en servidores. Un servidor al que acceda un número bastante elevado de personas tendrá que tener un buen rendimiento para soportar la carga, en caso contrario los usuarios experimentarán cuelgues o paradas molestas. Dependiendo de para qué vaya a estar destinado el equipo, será mejor idea tener un buen rendimiento en CPU, en I/O, en red, etc.
Hoy para comenzar, vamos a presentar el software sysbench, que permite realizar diferentes tipos de test sobre la máquina para averiguar su rendimiento en cuanto a cálculo, I/O, memoria, etc. sysbench está disponible para prácticamente todos los sistemas, y para sistemas Debian y derivados , la instalación es inmediata desde los repositorios.
shell> apt-get install sysbench
Una vez instalado tendremos ya a nuestra disposición el comando con el que podremos realizar los tests.

Test de CPU

Con este benchmark podremos testear el rendimiento de la CPU de nuestro equipo, obligándole a realizar algunos cálculos que se consideran costosos y mostrándonos el tiempo final. Esto es especialmente útil sobre todo en máquinas virtuales o compartidas, en las que no sabemos el chip que tenemos debajo ni cuanta prioridad nos dio el administrador.
shell> sysbench --test=cpu --num-threads=1 --cpu-max-prime=20000 run
sysbench 0.4.12:  multi-threaded system evaluation benchmark

Running the test with following options:
Number of threads: 1

Doing CPU performance benchmark

Threads started!
Done.

Maximum prime number checked in CPU test: 20000


Test execution summary:
    total time:                          43.9480s
    total number of events:              10000
    total time taken by event execution: 43.9363
    per-request statistics:
         min:                                  4.28ms
         avg:                                  4.39ms
         max:                                  6.55ms
         approx.  95 percentile:               4.48ms

Threads fairness:
    events (avg/stddev):           10000.0000/0.00
    execution time (avg/stddev):   43.9363/0.00
Como podéis observar, se le indica el proceso a ejecutar y también el número de hilos que nos interesa que emplee. Esto nos da un resultado final que es el que tendremos que comparar con una máquina referencia de la que sí conozcamos el chip y el rendimiento que ofrece.

Test de I/O

Este es el otro test importante que se puede evaluar y efectuar con sysbench. Permite evaluar la potencia de I/O de los discos, algo que suele definir el rendimiento final de un equipo, la entrada/salida. Aquí existen muchas opciones que se le pueden pasar para realizar las comprobaciones, pero lo principal es preparar los ficheros con los que se operará. Se recomienda emplear ficheros que dupliquen por lo menos la cantidad de RAM disponible en el sistema. Si esto no es posible, habrá que indicarle que no emplee memoria caché, para evitar obtener resultados no reales.
Pues comenzamos por lo tanto creando el entorno de trabajo (los ficheros).
shell> sysbench --test=fileio --file-total-size=5G prepare
Una vez creados, ya sólo nos queda ejecutar el test y esperar por lo resultados.
shell> sysbench --test=fileio --file-total-size=5G \
       --file-test-mode=rndrw --init-rng=on \
       --max-time=300 --max-requests=0 run
sysbench 0.4.12:  multi-threaded system evaluation benchmark

Running the test with following options:
Number of threads: 1
Initializing random number generator from timer.


Extra file open flags: 0
128 files, 40Mb each
5Gb total file size
Block size 16Kb
Number of random requests for random IO: 0
Read/Write ratio for combined random IO test: 1.50
Periodic FSYNC enabled, calling fsync() each 100 requests.
Calling fsync() at the end of test, Enabled.
Using synchronous I/O mode
Doing random r/w test
Threads started!
Time limit exceeded, exiting...
Done.

Operations performed:  29580 Read, 19720 Write, 62984 Other = 112284 Total
Read 462.19Mb Written 308.12Mb Total transferred 770.31Mb (2.5676Mb/sec)
  164.32 Requests/sec executed

Test execution summary:
    total time:                          300.0167s
    total number of events:              49300
    total time taken by event execution: 279.2442
    per-request statistics:
         min:                                  0.01ms
         avg:                                  5.66ms
         max:                                302.36ms
         approx.  95 percentile:              15.31ms

Threads fairness:
    events (avg/stddev):           49300.0000/0.00
    execution time (avg/stddev):   279.2442/0.00
Para finalizar, borramos todo el espacio de disco que hemos ocupado, pues ya tenemos los resultados deseados.
shell> sysbench --test=fileio --file-total-size=5G cleanup

Para más información sobre sysbench, consultar la pagina man.
En breves saldrá la nuevo entrada Linux benchmark II, donde explicaremos el benchmarck a MySQL.

La entrada Linux benchmark I la puede leer en Puppet Linux.
Leer más

Linux y el uso de memoria

Este artículo lo escribo para esclarecer un poco el uso de la memoria que hace GNU/Linux y que difiere un poco a lo que nos tiene acostumbrados Windows. Lo primero que debemos de tener claro es que Linux no consume más RAM de la que necesita. Sí es cierto que hace un empleo más eficiente de la misma, para acelerar aplicaciones. Esto es lo que se conoce como memoria caché. La primera vez que te fijas en la memoria que se usa, puede que quedes asustando. Ejecutas el comando top y observas lo siguiente,
top - 19:36:09 up 3 days,  7:50,  8 users,  load average: 1.94, 1.57, 1.30
Tasks: 191 total,   2 running, 187 sleeping,   0 stopped,   2 zombie
Cpu(s): 23.4%us, 30.8%sy,  0.0%ni, 45.4%id,  0.3%wa,  0.0%hi,  0.0%si
Mem:   2065160k total,  1950980k used,   114180k free,    23344k buffers
Swap:  1951888k total,   295528k used,  1656360k free,   384324k cached
En este caso, quedan aproximadamente 100Mb de memoria libre (114180k) y tengo prácticamente 2Gb de ella usada. Si mi sistema no está haciendo nada, entonces ¿qué pasa?
GNU/Linux emplea masivamente la memoria RAM para cachear aquellas partes del disco o aplicaciones que se han abierto recientemente.
La forma más sencilla de explicarlo es con un ejemplo. Abrimos Google-Chrome y lo cerramos. Parte de los datos y librerías necesarias para usarlo quedarán residualmente en la memoria durante un tiempo por si lo volvemos a abrir. Esto presenta la ventaja de que si lo volvemos a arrancar, el proceso será mucho más rápido (no hay que acceder a disco). En caso contrario, si la memoria es requerida, se liberará.
Se puede alterar este comportamiento, pero para la mayoría de los usuarios el kernel gestionará de forma eficiente la RAM.
Y si quiero saber la memoria exacta que tengo libre, ¿cómo hago?
Muy sencillo. Para saberlo debes emplear el comando free y fijarte en la tercera línea, que es la que realmente da los datos de interés.
shell> free -m
             total    used    free    shared    buffers    cached
Mem:          2016    1910     106         0         23       383
-/+ buffers/cache:    1502     513
Swap:         1906     288    1618
Como vemos, el comando free devuelve unos valores muy similares a top (algo lógico), pero si nos fijamos en la línea -/+ buffers/cache veremos la parte que nos interesa, la cantidad de RAM libre que realmente tiene el sistema, pues la memoria caché se debe considerar también memoria libre.
Como veis no son 100Mb, sino 512Mb, lo cual ya está mejor.

La entrada Linux y el uso de memoria la puedes leer en Puppet Linux.
Leer más

SSH, remote port to local port

Este es un pequeño y sencillo truco que muchas veces se nos olvida. SSH tiene la posibilidad de compartir puertos, tanto de local a remoto como de remoto a local. Muchas veces puede que tengamos acceso al puerto SSH de un equipo, pero no a otros puertos o a puertos de otros equipos. Entonces... ¿Cómo accedemos a diferentes puertos? Con SSH y el nateo de puertos, o lo que es lo mismo, estableciendo un túnel SSH. Con algo tan sencillo como
shell> ssh -L 8080:localhost:80 equipo.remoto.com
conseguimos que bajo el puerto 8080 de nuestro equipo local (localhost) esté el mismo contenido disponible que en el 80 del equipo remoto.
En caso de que nos interese ir un paso más allá, podremos hacerlo tal que así,
shell> ssh -L 8080:segundo.remoto.com:80 primero.remoto.com
En este caso, en localhost tenemos el puerto 80 de un equipo al que no podemos acceder, pero al que el equipo remoto sí puede acceder.
Posibilidades de SSH, muchas ;-)

La entrada SSH, remote port to local port la puedes leer en Puppet Linux.
Leer más

Comandos interesantes, ioping

Recientemente he publicado una entrada sobre iostat, cómo usarlo y cómo interpretar los resultados que se obtenían de su ejecución. Hoy acabo de descubrir una nueva utilidad que sirve para hacer algo muy similar. No ofrece tanta información, pero sí la importante y de forma sencilla y rápida nos permite consultar el rendimiento de entrada/salida de un disco. Esta nueva herramienta se llama ioping. Sí, ping I/O. Está disponible en los repositorios de Ubuntu y también en los de Debian, aunque actualmente sólo de testing en adelante.
ioping permite obtener el rendimiento del acceso a disco de un equipo al igual que si estuviésemos ejecutando un ping a la red. De hecho, qué mejor que un ejemplo de la salida para verlo,
shell> ioping -c 10 -s 1M -D /tmp
1048576 bytes from /tmp (ext4 /dev/sda1): request=1 time=34.0 ms
1048576 bytes from /tmp (ext4 /dev/sda1): request=2 time=23.0 ms
1048576 bytes from /tmp (ext4 /dev/sda1): request=3 time=23.2 ms
...

--- /tmp (ext4 /dev/sda1) ioping statistics ---
10 requests completed in 9268.4 ms, 37 iops, 37.4 mb/s
min/avg/max/mdev = 23.0/26.7/34.0/4.4 ms
Por lo tanto, ioping permite obtener la latencia de entrada/salida de disco pudiéndonos ser útil para saber la potencia de lectura o escrita que el disco ofrece, empleando o no la caché. Las principales opciones que presenta son:
  • -c count
    Se ejecuta count veces y luego termina ofreciendo una estadística de resultados.
  • -s size
    Establece el tamaño de la lectura/escritura que realizará.
  • -L
    Realiza las operaciones de forma secuencial y no aleatorias.
  • -C
    Comprueba la latencia del disco empleando la caché.
  • -D
    Comprueba la latencia escribiendo en disco directamente.
Para más información, consultar la página de su manual.
Página oficial de ioping: code.google.com/ioping

La entrada Comandos interesantes, ioping la puede leer en Puppet Linux.
Leer más

SSH logout automático

Fijo que a muchos de vosotros os ha pasado alguna vez lo de dejar una sesión SSH abierta en un equipo hasta el día siguiente o la media hora del café. Ahora imaginarios que el equipo no quedase bloqueado y que algún curiosos se acercase. Una sesión abierta en una máquina abandonada nunca es buena combinación. Para evitar este tipo de despistes, vamos a configurar nuestro servidor SSH para que haga un logout automática de aquellas cuentas que no muestren actividad pasado un tiempo. Este tiempo debe ser prudencial, por ejemplo 10 minutos (600 segundos).
Para hacerlo debemos de editar el fichero de configuración del servidor SSH (/etc/ssh/sshd_config) y meter los siguientes valores,
ClientAliveInterval 600
ClientAliveCountMax 0
Tras hacerlo, simplemente reiniciamos el servicio SSH para que recargue los nuevos valores.
shell> service sshd restart
Ahora si no hay actividad en una cuenta durante 10 minutos esta será automáticamente cerrada por el sistema, evitando así las "sesiones olvidadas".
SSH también no permite definir el tiempo que transcurre desde que un usuario pide sesión hasta que éste se autentica. Es la variable
LoginGraceTime 30
la cual también podemos y debemos acortar para evitar dejar un tiempo excesivo un intento de login.

La entrada SSH logout automático la puedes leer en Puppet Linux.
Leer más

Históricos de dispositivos USB en Windows

Windows, el sistema más usado actualmente, es una fuente de sabiduría. Todo lo que pasa en él se queda, por lo general, almacenado en el registro. Hoy os dejo la ruta para que podías averiguar todos los dispositivos USB que se han conectado a lo largo de la vida del equipo a vuestra máquina. Puede que no tenga demasiado interés, pero siempre es bueno recordarlo.
HKEY_LOCAL_MACHINE\
 |
 -SYSTEM\
  |
  -CurrentControlSet\
   |
   -Enum\
    |
    -USBSTOR
Leer más

Consejos para tus sistemas virtuales

Cada vez es más común el uso de máquinas muy grandes y potentes que luego virtualizan a otras más pequeñas, para así aprovechar mejor el rendimiento. En entornos grandes, donde la virtualización comienza a mandar desde hace unos años, se emplean grandes plataformas que permiten hacerlo y aislar las máquinas virtuales de las máquinas físicas. Bien empleen xen, vmware o Microsoft Windows Hyper-V. Proteger el entorno y por lo tanto todas las máquinas del mismo es importante, ya que si se consigue un acceso no deseado a una de las máquinas, por el fallo que sea, quizás éste se pueda extender a más máquinas. Por lo tanto os dejo una serie de consejos que espero os sean de utilidad a la hora de proteger y montar vuestra infraestructura virtual.
  1. Si empleas máquinas virtuales, piensa que no es la panacea de "esto lo aguanta todo". Por norma general la entrada/salida a disco será la que más se vea afectada. Tenlo en cuenta o podrás hacer que todas las máquinas fallen al compartir discos/cabinas.
  2. Usa sistemas de replicación. Un host físico es un único punto de fallo que involucra a muchas máquinas. Los sistemas de virtualización modernos permiten replicación y trabajo en HA.
  3. Aísla unas máquinas de otras si no necesitan tener acceso y visibilidad entre ellas. Los dominios cero permiten establecer VLAN's. Si un grupo de máquinas no necesita ver a otro, mejor aislarlas lo máximo posible. Una solución de VLAN es buena.
  4. Si puedes emplea tarjetas de red indipendientes para cada una de las VLAN's.
  5. Haz un control estricto de quién entra a las máquinas, pero más de quién accede al host físico, que es el que realmente controla todo.
  6. Usa únicamente las máquinas virtuales que necesites. Si una máquina no está siendo usada, no la tengas levantada "por que no consume". Esto puede traer problemas de seguridad. Apágala.
  7. Instala sólo el software que necesites en cada equipo. Piensa que cada nuevo servicio que instales es un nuevo servicio que hay que configurar, actualizar y mantener.
  8. Mantén tu máquina virtual al día. Aplica actualizaciones de seguridad y comprueba su estado. Que sea virtual no quiere decir que no necesite mantenimiento, es un servidor al fin y al cabo.
  9. Instala un firewall y establece políticas de acceso en cada una de las máquinas. Una máquina virtual no está protegida por su dominio cero, a nivel IP es igual de vulnerable. Así que controla lo que abres y a quién permites acceso.
  10. Evita dentro de lo posible la navegación desde las máquinas virtuales. Si no son para tal fin, úsalas sólo para lo que estén hechas. Los virus y demás fauna también las atacan.
  11. Controla a quién dejas acceso. Haz mantenimiento de cuentas de usuario y permisos.
Leer más

Mimando y controlando los discos

Los discos duros son una de las partes fundamentales de nuestros equipos. Efectivamente, al igual que sin procesador o RAM, un equipo sin disco no puede funcionar (salvemos las distros en live), pero el disco sin embargo es la parte más fundamental por que es donde guardamos toda la información. Controlar el estado de vida del disco es muy importante, al igual que es hacer una buena copia de seguridad de todos nuestros datos. Desde GNU/Linux tenemos la posibilidad de vigilar los discos de forma sencilla con la utilidad smartmontools. Gracias a estar magnífica herramienta podemos obtener una serie de parámetros sobre los discos, desde temperatura hasta número de horas que lleva en funcionamiento. Y también, como era de esperar, recibir alertas en caso de que el disco esté dando algún tipo de fallo.
Vamos a comenzar por instalarlo. smartmontools está prácticamente disponible en los repositorios de cualquier distribución. En Debian/Ubuntu,
shell> apt-get install smartmontools
Tras esto, ya tenemos disponible el comando smartctl y el daemon smartd. Vamos a comenzar por ver la información que se puede extraer con el comando y luego veremos cómo configurar el daemon para que nos alerte de situaciones anómalas en los discos del equipo.
  • Información general
    Con la opción -i obtenemos información general del disco en cuestión. Versión del firmware, dispositivo, modelo, número de serie, etc.
    shell> smartctl -i /dev/sda
    === START OF INFORMATION SECTION ===
    Model Family:     Western Digital Caviar SE Serial ATA family
    Device Model:     WDC WD1600JS-08NCB1
    Serial Number:    WD-WMANM7963047
    Firmware Version: 10.02E01
    User Capacity:    160,041,885,696 bytes
    Device is:        In smartctl database [for details use: -P show]
    ATA Version is:   7
    ATA Standard is:  Exact ATA specification draft version not indicated
    Local Time is:    Mon Apr  1 11:26:09 2013 CEST
    SMART support is: Available - device has SMART capability.
    SMART support is: Enabled
    
  • Información detallada
    La opción -a nos ofrece la misma información que la anterior y a mayores más detalles como las horas de funcionamiento, la temperatura, veces que se ha encendido, etc.
    shell> smartctl -a /dev/sda
    === START OF INFORMATION SECTION ===
    Model Family:     Western Digital Caviar SE Serial ATA family
    Device Model:     WDC WD1600JS-08NCB1
    Serial Number:    WD-WMANM7963047
    Firmware Version: 10.02E01
    User Capacity:    160,041,885,696 bytes
    Device is:        In smartctl database [for details use: -P show]
    ATA Version is:   7
    ATA Standard is:  Exact ATA specification draft version
    Local Time is:    Mon Apr  1 11:28:57 2013 CEST
    SMART support is: Available - device has SMART capability.
    SMART support is: Enabled
    
    === START OF READ SMART DATA SECTION ===
    SMART overall-health self-assessment test result: PASSED
    See vendor-specific Attribute list for marginal Attributes.
    
    ...
    
    SMART Attributes Data Structure revision number: 16
    Vendor Specific SMART Attributes with Thresholds:
    ID# ATTRIBUTE_NAME          FLAG     VALUE WORST THRESH TYPE
      1 Raw_Read_Error_Rate     0x000f   200   200   051    Pre-fail
      3 Spin_Up_Time            0x0003   179   178   021    Pre-fail
      4 Start_Stop_Count        0x0032   100   100   000    Old_age
      5 Reallocated_Sector_Ct   0x0033   200   200   140    Pre-fail
      7 Seek_Error_Rate         0x000f   200   200   051    Pre-fail
      9 Power_On_Hours          0x0032   044   044   000    Old_age
     10 Spin_Retry_Count        0x0013   100   100   051    Pre-fail
     11 Calibration_Retry_Count 0x0012   100   100   051    Old_age
     12 Power_Cycle_Count       0x0032   100   100   000    Old_age
    190 Airflow_Temperature_Cel 0x0022   064   041   045    Old_age
    194 Temperature_Celsius     0x0022   111   088   000    Old_age
    196 Reallocated_Event_Count 0x0032   200   200   000    Old_age
    197 Current_Pending_Sector  0x0012   200   200   000    Old_age
    198 Offline_Uncorrectable   0x0010   200   200   000    Old_age
    199 UDMA_CRC_Error_Count    0x003e   200   200   000    Old_age
    200 Multi_Zone_Error_Rate   0x0009   200   200   051    Pre-fail
    
    SMART Error Log Version: 1
    No Errors Logged
    
    SMART Self-test log structure revision number 1
    Num  Test_Description  Status              Remaining  LifeTime(h)
    # 1  Short offline     Completed without error   00%     41414
    
    ...
    
  • Test de estado
    La opción -H realiza un pequeño test que indica si el estado del disco es correcto
    shell> smartctl -H /dev/sda
    === START OF READ SMART DATA SECTION ===
    SMART overall-health self-assessment test result: PASSED
    
    o incorrecto y está a punto de morir.
    shell> smartctl -H /dev/sda
    === START OF READ SMART DATA SECTION ===
    SMART overall-health self-assessment test result: FAILED!
    
  • Test con datos relevantes
    smartctl también se puede programar para que realice un test al disco y obtener más datos. Dependiendo del test a realizar la información se devolverá en el momento o tardará en realizarse.
    shell> smartctl -t short /dev/sda
    === START OF OFFLINE IMMEDIATE AND SELF-TEST SECTION ===
    Testing has begun.
    Please wait 2 minutes for test to complete.
    Test will complete after Mon Apr 5 18:28:37 2013
    
    Use smartctl -X to abort test.
    
    En caso de que tarde en devolvernos los datos, estos podrán ser consultados a posteriori tal que así,
    shell> smartctl -l selftest /dev/sda
    === START OF READ SMART DATA SECTION ===
    SMART Self-test log structure revision number 1
    Num  Test_Description  Status              Remaining  LifeTime(h)
    # 1  Short offline   Completed without error     00%     41414
    
  • Más información sobre smartctl en la página de su manual.
smartmontools también incluye un pequeño demonio que permite ejecutarse, controlar y enviar información del estado de los discos que le indiquemos que controle. Por defecto dicha información la enviará a syslog. Para configurar el daemon tendremos que editar el fichero /etc/default/smartmontools,
enable_smart="/dev/sda /dev/sdb"
start_smartd=yes
Y arrancar el daemon.
shell> /etc/init.d/smartmontools start
La primera variable nos indica los diferentes discos a monitorizar y la segunda permite que se arranque como servicio. A partir de ahora nos irá dando información de los discos y en caso de que hay algo "raro" en los mismos nos alertará por syslog. Por ejemplo,
Device: /dev/sda, FAILED SMART self-check. BACK UP DATA NOW!
Device: /dev/sda, Failed SMART usage Attribute: 5 Reallocated_Sector_Ct.
Device: /dev/sda, Self-Test Log error count increased from 4 to 5
Espero que os sea de utilidad y acordaros: BACK UP DATA NOW!

La entrada Mimando y controlando los discos la puedes leer en Puppet Linux.
Leer más

iostat

iostat es una de esas utilidades de GNU/Linux que todo administrador debería de conocer y comprender perfectamente. iostat permite monitorizar los parámetros de entrada/salida de los diferentes dispositivos del sistema, para observar los diferentes ratios de transferencia.
Una de las típicas salidas de iostat es la siguiente,



shell> iostat
Linux 2.6.32-5-686 (desktop)   03/31/13   _i686_ (2 CPU)

avg-cpu:  %user       %nice     %system   %iowait    %steal  %idle
           4,25        0,00        1,01      0,51      0,00  94,22

Device:     tps  Blk_read/s  Blk_wrtn/s  Blk_read  Blk_wrtn
sda        7,32       66,51      112,61    835334   1414278
Aunque aquí nos muestra también el consumo de CPU del sistema, la parte más importante está a continuación y es la que se refiere a los discos. De hecho, si llamamos a iostat para que nos saque información continuada de los discos, vemos que se suprime la información relativa a la carga de CPU.
shell> iostat -d 2 3
Linux 2.6.32-5-686 (desktop)   03/31/13   _i686_ (2 CPU)

Device:     tps   kB_read/s   kB_wrtn/s   kB_read   kB_wrtn
sda       11,79      210,97       95,91   1171053    532364

Device:     tps   kB_read/s   kB_wrtn/s   kB_read   kB_wrtn
sda        2,79       80,45        0,00       144         0

Device:     tps   kB_read/s   kB_wrtn/s   kB_read   kB_wrtn
sda       24,16        0,00      191,01         0       340
Pero el problema de iostat no está en conseguir hacer funcionar el comando, sino en saber interpretar la salida. Saber qué significa tps, kB_wrtn, etc. Esto es muy sencillo,
  • tps
    Es la transferencia a disco por segundo.
  • Bls_read/s (kB_read/s, MB_read/s)
    Es la cantidad de bloques leídos por segundo.
  • Bls_wrtn/s (kB_wrtn/s, MB_wrtn/s)
    Representa la cantidad de bloques escritos por segundo.
  • Blk_read (kB_read, MB_read)
    Bloques totales leídos.
  • Blk_wrtn (kB_wrtn, MB_wrtn)
    Bloques totales escritos.

La entrada iostat la puedes leer en Puppet Linux.
Leer más

Automater y la información en la red

Fin de semana lluvioso. Google Reader cerrará sus puertas en poco tiempo. Qué mejor qué hacer que ir suprimiendo artículos pendientes de lectura. En este caso, me refiero a un post de hace ya un mes que salió en Security by default y que hacía repaso a la herramienta Automater, un pequeño programa escrito en Python que permite obtener información sobre direcciones IP's o URL's. Automater es uno de esos script que siempre hay que tener a mano para analizar cualquier IP que nos interese. Permite obtener información muy rápida y válida. Desde localizaciones geográficas de la misma hasta el operador propietario de la misma. También permite saber si dicha IP/URL está en alguna de las listas negras reconocidas de la red y como truco interesante, permite analizar la URL destino de un acortador de URL's.
Para aclarar mejor para qué sirve, nada mejor que verlo en funcionamiento.
shell> python Automater.py -t *.*.*.7
  ___        _                        _            
 / _ \      | |                      | |           
/ /_\ \_   _| |_ ___  _ __ ___   __ _| |_ ___ _ __ 
|  _  | | | | __/ _ \| '_ ` _ \ / _` | __/ _ \ '__|
| | | | |_| | || (_) | | | | | | (_| | ||  __/ |   
\_| |_/\__,_|\__\___/|_| |_| |_|\__,_|\__\___|_|   

--------------------------------
[*] *.*.*.7 is an IP. 
[*] Running IP toolset
[+] A records from Robtex: domain.eu
[+] A records from Robtex: int-static-*-7.---.es
[+] A records from Robtex: ---.es
[+] A records from Robtex: ---.com
[+] A records from Robtex: ---.com
[+] A records from Robtex: ---.es
[+] A records from Robtex: ---.net
[+] A records from Robtex: ---.org
[+] A records from Robtex: www.---.es
[*] Scanning host now on IPVoid.com.  May take a few seconds.
[-] IP is not listed in a blacklist
[+] The ISP for this IP is: R Cable y Telecomunicaciones Galicia, S.A.
[+] Geographic Location: (ES) Spain
[-] FortiGuard URL Categorization: Uncategorized
[-] IP is not listed in AlienVault IP reputation database
En este ejemplo obtenemos información relativa a la IP solicitada. Vemos todas las resoluciones DNS inversas que tiene (sólo de tipo A) así como la localización de la misma y el ISP propietario de la misma.
shell> python Automater.py -t https://mail.google.com/
  ___        _                        _            
 / _ \      | |                      | |           
/ /_\ \_   _| |_ ___  _ __ ___   __ _| |_ ___ _ __ 
|  _  | | | | __/ _ \| '_ ` _ \ / _` | __/ _ \ '__|
| | | | |_| | || (_) | | | | | | (_| | ||  __/ |   
\_| |_/\__,_|\__\___/|_| |_| |_|\__,_|\__\___|_|   

--------------------------------
[*] https://mail.google.com/ is a URL.  
[*] Running URL toolset
[-] https://mail.google.com/ is not a recognized shortened URL.
[*] Scanning host now on URLVoid.com.  May take a few seconds.
[+] Host IP Address is 173.194.35.53
[-] IP is not listed in a blacklist
[+] Latitude / Longitude: 37.4192 / -122.057
[+] Country:  (US) United States
[+] Domain creation date: 1997-09-15 (16 years ago)
[-] FortiGuard URL Categorization: Uncategorized
En este ejemplo, realizamos la petición sobre una URL bastente conocida, de la que obtenermos información más exacta sobre su localización, así como información relativa a la creación de su dominio.
Y ya para finalizar, podemos ver qué sucede si pedimos información sobre un enlace acortado,
shell> python Automater.py -t bit.ly/123WhVJ 
  ___        _                        _            
 / _ \      | |                      | |           
/ /_\ \_   _| |_ ___  _ __ ___   __ _| |_ ___ _ __ 
|  _  | | | | __/ _ \| '_ ` _ \ / _` | __/ _ \ '__|
| | | | |_| | || (_) | | | | | | (_| | ||  __/ |   
\_| |_/\__,_|\__\___/|_| |_| |_|\__,_|\__\___|_|   

--------------------------------
[*] bit.ly/123WhVJ is a URL.  
[*] Running URL toolset
[+] bit.ly/123WhVJ redirects to: http://www.enricozini.org/2013/debian/on-gender-imbalance/
[+] Host IP Address is 69.58.188.39
[+] Host is listed in blacklist at http://www.phishtank.com/
[+] Host is listed in blacklist at http://www.scumware.org/search.scumware
[+] Host is listed in blacklist at http://www.spamhaus.org/query/domain/bit.ly
[+] Latitude / Longitude: 40.733 / -74.0078
[+] Country:  (US) United States
[+] Domain creation date: 2008-05-18 (5 years ago)
[-] FortiGuard URL Categorization: Uncategorized

Más información: SecurityByDefault.

La entrada Automater y la información en la red, la puedes leer en Puppet Linux.
Leer más

Formato de fechas en bash

Cada vez que tengo que manejar una fecha en GNU/Linux sé qué comando usar, date, pero cada vez que hay que darle un formato me pasa lo mismo. ¿Cómo se hacía para que saliera...? Así que a modo de chuleta me he escrito esta entrada donde dejaré plasmado el uso del comando date, así como los formatos de salida que soporta dicho comando.
Al ejecutar date en bash se obtiene ya la salida con la fecha actual completa,
shell> date
Wed Mar 29 19:32:29 CET 2013
El problema viene cuando deseamos sacar sólo una parte de dicha fecha, el año, las horas, la zona horaria, etc. Para hacer eso hay que emplear los acondicionadores de formato que se muestran en la tabla inferior e indicarle a date que los use con un +"". Vamos a poner algún ejemplo que nos ayude a esclarecer el empleo de dichos formatos.
  • Año-Mes-Día
    shell> date +"%Y-%m-%d"
    2013-03-27
    
  • Hora:Minutos:Segundos
    shell> date +"%T"
    10:49:28
    
  • Hora en formato 12
    shell> date +"%r"
    10:36:06 AM
    
Aprovechando esta entrada, también vamos a explicar cómo obtener con el mismo comando otra fecha que no sea la actual, ya bien sea una fecha futura o una pasada. Para conseguir hacer eso, debemos de usar la opción --date='...'. Esta opción es 100% compatible con el formato de fechas explicado con antelación.
  • Día de ayer
    shell> date +"%Y-%m-%d"
    2013-03-27
    shell> date --date='-1 day' +"%Y-%m-%d"
    2013-03-26
    
  • El mes pasado
    shell> date --date='-1 month' +"%Y-%m-%d"
    2013-02-27
    
  • El año que viene
    shell> date --date='+1 year' +"%Y-%m-%d"
    2014-03-27
    
Y como nota final, queda a continuación.
Formato
Significado
%%Imprime %.
%aAbreviatura del día de la semana, respetando el idioma.
Ejemplo: Sun.
%ADía completo de la semana. Respeta el idioma.
Ejemplo: Sunday.
%bAbreviatura del mes.
Ejemplo: Jan
%BNombre del mes completo.
Ejemplo: January
%cImprime la fecha y la hora respetando el idioma.
Ejemplo: Thu Mar 3 23:05:56 2013.
%CImprime el siglo. Tiene el mismo significado que "%Y", excepto que no muestra los dos últimos dígitos.
Ejemplo: 20.
%dDía del mes.
Ejemplo: 02.
%DFecha. Mismo significado que "%m/%d/%y".
%eDía del mes. Es lo mismo que "%_d".
%FFecha completa. Es lo mismo que "%Y-%m-%d".
%gÚltimos 2 dígitos del año, respetando el formato ISO de número de semanas.
%GAño completo, respetando el formato ISO de número de semanas.
%hAbreviatura del mes.
Ejemplo: Jan
%HHora (00...23).
%IHora (01...12).
%jDía del año (001...206).
%kHora (0...23).
%lHora (1...12).
%mMes (01...12).
%MMinutos (00...59).
%nLínea en blanco
%NNanosegundos (000000000...999999999)
%pImprime el tipo de hora local. AM o PM.
Si es desconocido, no saca nada.
%PLo mismo que "%p", pero en minúsculas.
%rHora exacta en formato 12 horas.
Ejemplo: 11:11:11 AM.
%RImprime horas, en formato 24 horas y minutos. Es lo mismo que "%H:%M".
%sSegundos desde 1970-01-01 00:00:00 UTC.
%SSegundos (00...60).
%tTabulación.
%THora; lo mismo que "%H:%M:%S".
%uDía de la semana (1...7). El 1 se corresponde a Lunes.
%UNúmero de semana del año (00...53). Se consideran el Domingo primer día de la semana.
%VISO número de la semana (01...53). El Lunes es el primer día de la semana.
%wDía de la semana (0...6). El 0 es Domingo.
%WNúmero de semana del año (00...53). El Lunes es el primer día de la semana.
%xImprime la fecha de acuerdo con el formato local.
Ejemplo: 03/24/13.
%XImprime la hora en formato local.
Ejemplo: 16:15:52.
%yÚltimos dos dígitos del año (00..99).
%YAño.
%z+hhmm zona horaria.
Ejemplo: -0400.
%:z+hh:mm zona horaria.
Ejemplo: -04:00.
%::z+hh:mm:ss zona horaria.
Ejemplo: -04:00:00.
%:::zZona horaria con precisión.
Ejemplo: -04, +05:30.
%ZZona horaria en formato alfabético.
En este blog podrás encontrar una nueva página que te permite realizar la conversión entre fechas. Podrás cambiar automáticamente entre unixtime a fecha en formato legible y viceversa. Siempre que lo necesites no dudes en emplearlo.

La entrada Formato de fechas en bash la puedes leer en El mundo en bits.
Leer más

nmap, netbios scan hostname

Hay veces que por alguna razón, bien interés, bien por que estemos haciendo una auditoría de red, sabemos que hay un equipo, una IP, que tiene un servicio NETBIOS corriendo, pero de él todavía no sabemos el nombre.
Por suerte, nmap nos puede ayudar a averiguarlo de una forma bastante rápida,

shell> nmap -script smb-os-discovery.nse -p445 192.168.0.35

Starting Nmap 6.00 ( http://nmap.org ) at 2013-04-06 18:36 CEST
Nmap scan report for 192.168.0.35
Host is up (0.0022s latency).
PORT    STATE SERVICE
445/tcp open  microsoft-ds

Host script results:
| smb-os-discovery: 
|  OS: Unix (Samba 3.5.6)
|  Computer name: samba
|  Domain name: domain.com
|  FQDN: samba.domain.com
|  NetBIOS computer name: 
|  NetBIOS domain name: HOME
|_ System time: 2013-04-06 18:36:08 UTC+2

Nmap done: 1 IP address (1 host up) scanned in 0.43 seconds

La entrada nmap, netbios scan hostname la puedes leer en El mundo en bits.
Leer más

Comandos interesantes, badblocks

A quién no lo ha pasado que su disco duro le ha dado fallos o tiene algún sector defectuoso. Muchas veces el disco con el uso presenta algún sector defectuoso al que no se puede acceder y que por lo tanto dicha información se va perdiendo, así como capacidad del disco. En Windows existía el famoso chkdsk (checkdisck) y en GNU/Linux está el comando badblocks, que hace algo muy similar, aunque con mayor potencia. badblocks, a parte de recuperar los posibles sectores defectuosos del disco, también permite realizar un escaneo del mismo más exhaustivo, así como realizar un formateo del dispositivo rellenando con valores aleatorios todos los sectores.
Vamos a ver su funcionamiento con unos ejemplos.
  • Escaneo en modo RO
    Este tipo de escaneo hará sólo una lectura de los datos, pero en ningún momento escribirá nada en el disco, por lo que la información no correrá peligro.
    shell> badblocks -svf /dev/sda
    
  • Escaneo en modo RW
    Al contrario que el anterior modo, aquí sí se perderán datos. El escaneo se encargará de leer cada bloque, escribirlo con un valor y volver a leerlo.
    shell> badblocks -nsvf /dev/sda
    
  • Escaneo en modo W
    En este caso, se escribirá en cada sector un patrón y se comprobará que se lee correctamente. Al igual que en el modo RW, toda la información se perderá.
    shell> badblocks -wsvf /dev/sda
    
    En caso de que se añada el flag random, los valores escritos serán completamente aleatorios, lo que conducirá a una destrucción más segura de los datos del disco.
    shell> badblocks -t random -wsvf /dev/sda
    
El significado de las principales opciones que badblocks permite son:
  • - s: Muestra el progreso.
  • - v: Modo detallado.
  • - n: Modo RW no destructivo.
  • - w: Modo escritura (destructivo).
  • - t random: Escribe (o lee) de forma y con valores aleatorio.
  • - f: Repara los sectores dañados.
La entrada Comandos interesantes, badblocks la puedes leer en Puppet Linux.
Leer más

Formulario de contacto

Nombre

Correo electrónico *

Mensaje *

Últimos comentarios