Empleando pagefile en GNu/Linux

Esta entrada va dedicado a toda aquella gente que viene de sistemas Windows, acostumbrada a tener un fichero de swap en disco y que lo desea seguir manteniendo en GNU/Linux.

Por defecto, cuando se instala un sistema Linux, siempre es aconsejable y muy recomendable crear un partición de tipo swap que el sistema manejará y empleará para dicha tarea de forma automática. Si tienes varias distribuciones instaladas en el mismo equipo, todas podrán compartir dicha partición, por lo que ahorrarás bastante espacio en disco.

Sin embargo, hay veces que puedes decidir no disponer de dicha partición. Por ejemplo, si tu equipo tiene mucha memoria RAM, más de 8Gb, es raro que termines usando la swap, por lo que podrás ahorrarte ese espacio de disco que nunca lo aprovecharás. Claro que siempre terminarás por hacer alguna tarea que requiera de swap, entonces en ese momento estás fastidiado y por suerte, gracias a dd, tendrás la solución al alcance del comando ;-)

La solución no es más que imitar lo que hace Windows con el fichero pagefile.sys, es decir, crear un fichero de tamaño limitado que se empleará dinámicamente de memoria swap. Para ello, y copiando el nombre empleado por Windows para dicho fichero, podemos hacer algo tal que así,

shell> dd if=/dev/zero of=/pagefile.sys bs=4k count=2048M

Con ello acabamos de crear sobre la partición raíz de nuestro sistema un fichero, pagefile.sys, de 2Gb de tamaño. A continuación tendremos que darle formato y emplearlo como memoria swap. Primeramente formateamos,

shell> mkswap /pagefile.sys

Y a continuación lo 'montamos' como memoria swap.

shell> swapon /pagefile.sys

Este sencillo truco lo tuve que usar un par de veces el mi portátil cuando comencé a darle mucha caña, tras seguir las recomendaciones de Optimización de Linux con discos SSD y la verdad es que me pareció muy interesante compartirlo con todos.

Leer más

Locuras del calor, llevar SWAP a RAM

Este post es de esos que hay que escribir por aprender y por utilizar, pero que realmente puede que nunca llegue a tener una utilidad real. Vamos a ver cómo emplear parte de la memoria RAM para colocar nuestra memoria SWAP, es decir, utilizar la RAM para cuando no tengamos RAM.

Aunque puede parecer un sin sentido, en realidad siempre se le pueden encontrar buenos motivos para emplearlo. A mi ahora mismo se me ocurren,

• Ver la versatilidad que GNU/Linux ofrece
• Optimizar/minimizar el acceso a disco
• Aprender cosas nuevas ;-)

Pero si tenemos que emplear caché es por que no tenemos más RAM, por lo que tenerla ahí ocupada no ayuda demasiado. Eso es cierto, pero el empleo de zRAM tiene la ventaja de que comprime los datos que emplea, por lo que 100Mb de caché pueden rendir como muchos más. A mayores tenemos la caché en memoria "rápida", por lo que incrementa el rendimiento del sistema y en equipos con mucha memoria y discos SSD, minimiza los accesos al mismo.

Pues una vez explicado la idea, vamos a ver cómo emplear zRAM. Para ello, tenemos que comprobar que nuestro sistema tiene soporte para ella,

shell> grep -i zram /boot/config-`uname -r`
CONFIG_ZRAM=m
# CONFIG_ZRAM_DEBUG is not set

En mi sistema zRAM está como un módulo del kernel, por lo que para usarlo debemos de cargar primero dicho módulo,

shell> modprobe zram

Una vez cargado tendremos un nuevo dispositivo, al cual tendremos que darle un tamaño. Es importante no pasarse, ya que este "disco" realmente no está comiendo la RAM, pero acordaros que luego trabaja con datos comprimidos. En mi caso voy a crear un dispositivo de 150Mb,

shell> echo $((150*1024*1024)) > /sys/block/zram0/disksize

Y a continuación, simplemente le indicamos a nuestro sistema que ese disco también forma parte de la SWAP.

shell> mkswap /dev/zram0
shell> swapon -p 10 /dev/zram0

En la segunda línea ejecutada montamos el disco como SWAP y le damos mayor prioridad que al resto de disco que tengamos configurado. Esto es necesario para que use esta partición virtual antes que la física, que es más lenta.

Si lo probáis ya contaréis qué tal la experiencia.

La entrada Locuras del calor, llevar SWAP a RAM lo puedes 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

zimbra, uso de RAM

Zimbra por defecto hace un uso intenso de la memoria RAM y de la SWAP para mejorar el rendimiento. Todo lo que puede lo almacena en caché, para así poder ofrecérselo antes a los clientes. Ésto hace que su rendimiento sea mayor, pero el consumo de recursos del sistema también es mayor. Para saber los valores que tienen las variables de reserva de RAM podemos ejecutar lo siguiente,

shell> zmlocalconfig |grep memory
mysql_memory_percent = 30
tomcat_java_heap_memory_percent = 60

Esto indica el procentaje de RAM que se reserva para MySQL (30%) y el porcentaje para los procesos de Zimbra (60%). En servidores con poca memoria disponible estos valores los hay que alterar para mejorar el rendimiento, ya que podemos tener MySQL con escasa RAM ejecutándose. En equipos con mucha RAM (más de 4Gb) también los podemos modificar para darles más recursos.

Para modificar dichos valores,

shell> zmlocalconfig -e mysql_memory_percent=50
shell> zmlocalconfig -e tomcat_java_heap_memory_percent=35

Tras ello, hay que reiniciar Zimbra.

Leer más

Seguridad en la RAM

Cuando estamos haciendo pruebas de pentesting y accedemos a un equipo, lo más importante es conseguir las contraseñas para poder volver a acceder. Una de las formas más sencillas es obtenerlas de los ficheros y luego "reventarlas" en local, por ejemplo. Pasar de un churro md5 a una contraseña. Si tenemos esto es genial, pero lo único que nos facilita es poder volver acceder al sistema, no obtenemos ningún dato más.

En un equipo con un uso normal, se emplean muchas contraseñas y muchas de las mismas pueden ser completamente diferentes, así que lo ideal sería poder obtenerlas. Un software bien diseñado almacena las contraseñas en memoria cifradas, sin embargo... ¿cuánto software de ese hay en un equipo? La gran mayoría dejará las contraseñas en texto plano en la memoria ram, así que sólo habrá que saber cómo buscarlas.

Indagando un poco, y la verdad es que poco, descubrí pd, un software que permite hacer volcados de la memoria de un proceso a fichero para luego examinar su contenido. Existe una versión para GNU/Linux y otra para Windows y aunque llevar tiempo sin actualizarse, la verdad es que sigue funcionando perfectamente. Lo único necesario es el PID del proceso. Es aquí donde tenemos que saber dónde buscar. Yo ejecutando un 'ps aux' en mi sistema tengo el proceso 'gnome-keyring-daemon' que me parece interesante, así que vamos a ver, paso a paso, cómo obtener la contraseña desde memoria.

• Obtenemos pd

  shell> wget \
  http://www.trapkit.de/research/forensic/pd/pd_v1.1_lnx.bz2
  shell> bunzip2 pd_v1.1_lnx.bz2
  shell> mv pd_v1.1_lnx pd
  

• Obtenemos el PID del proceso
  
  Para obtener el PID del proceso, simplemente ejecutamos un 'ps x' y filtramos por el proceso que nos interese. En mi caso, gnome-keyring-daemon.
  En sistemas Windows, para hacer el volcado se puede emplear la misma técnica, únicamente cambia la forma de averiguar el PID del proceso, que es con el comando tasklist.

  shell> ps x |grep gnome-keyring
  2432 ? Sl /usr/bin/gnome-keyring-daemon --daemonize --login
  2590 ? S  /usr/bin/gnome-keyring-daemon --start --components=secrets
  

• Volcado de memoria
  
  Sabiendo el PID del proceso, simplemente se lo pasamos como argumento y hacemos un redirect de la salida a un fichero, que posteriormente lo analizaremos.

  shell> ./pd_v1.1_lnx -p 2432 > key.dump
  pd, version 1.1 tk 2006, www.trapkit.de
  
  Dump complete.
  

• Data -> text
  
  Una vez que tenemos la salida de la memoria la podemos intentar comprender así, pero lo más sencillo es que hagamos uso del comando strings para obtener una salida más simple de comprender.

  shell> strings key.dump > key.txt
  

• Buscamos la contraseña
  
  Ahora que ya tenemos el volcado de memoria en formato texto, únicamente quedará por realizar la búsqueda de información sensible. Para ello, depende mucho del programa, pero generalmente tiene la cadena passwd, password, contraseña o similar y a continuación los datos que nos interesa. Por lo tanto, abrimos el fichero y se puede ver algo similar a lo que sigue.

  ...
  _Contrase
  minutos
  00004000
  AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAh?p
  .r4qu3l12
  zR:W
  mipasswdenclaro
  ...
  

Con esto que acabamos de descubrir podemos ver que el proceso gnome-keyring-daemon no es para nada seguro. ¿Qué pasará si analizamos sudo?

Leer más

Crear directorio en RAM

De todos es sabido que el acceso a memoria RAM es mucho más rápido que a disco, es por ello que en algunas ocasiones o lugares, optimizar el acceso a disco es muy importante para conseguir acelerar de manera notable ciertos programas.

Una buena idea sería tener todo el sistema en RAM, pero es algo que ahora mismo se podría considerar descabellado, sin embargo, localizar determinados directorios en RAM, puede acelerar considerablemente determinadas ejecuciones.

Un servicio que requiere mucha optimización, es por ejemplo, mysql, que siempre consume una gran cantidad de memoria. De cuanta más memoria disponga, mejor irá el sistema. Luego hay determinados datos que se procesan en directorio temporales. esto sucede en mysql, zabbix, apache, etc. Generalmente este directorio es /tmp y suele estar localizado en disco. La idea sería hacer que esté localizado en RAM y que al contener datos volátiles y "no importantes", aunque se pierdan no pasaría nada.

GNU/Linux para realizar esto, tiene un sistema de ficheros especial llamado tmpfs. Se puede usar configurando el /etc/fstab con los datos necesarios.

shell> cat /etc/fstab
...
tmpfs /tmp tmpfs rw,size=1G,nr_inodes=10k 0 0

En el caso puntual de que los ficheros no sean escritos por el usuario root, lo más lógico sería permitir escribir únicamente en ese espacio de memoria al usuario que lo necesite. Para eso, desde la propia línea de fstab se le pueden dar los permisos correctos.

Por ejemplo, para mysql,

shell> cat /etc/fstab
...
tmpfs /tmp/mysql tmpfs rw,uid=mysql,gid=mysql,size=1G,mode=700 0 0

Leer más

Configurar el uso de la SWAP

El área de intercambio o memoria swap es un fichero o una partición en el disco que se emplea para guardar páginas de memoria ram cuando esta queda escasa en el sistema. En GNU/Linux suele existir una o varias particiones especiales dedicadas a tal fin. Con varias, el comportamiento suele ser como un RAID 0, para así aumentar las escrituras,  También, desde Linux, se permite modificar la prioridad de los dispositivos, lo que influye en el rendimiento (opción --priority priority).

Sin embargo, en este post los que nos atañe es modificar la forma que tiene de comportase el kernel con el paso de datos entre la memoria y la swap.

shell> fdisk -l /dev/sda
   Device  Boot Start    End     Blocks  Id  System
/dev/sda1  *        1     61     489951  83  Linux
/dev/sda2          62    304   1951897+  82  Linux swap/Solaris
/dev/sda3         305  19457   85489866  8e  Linux LVM

El uso de swap hace que "aumente" la memoria ram disponible del sistema, pero a cambio disminuye el rendimiento, ya que la I/O a disco es más lento que a ram. Lo ideal siempre es no tener que usar swap, pero eso no siempre va a suceder, por lo que el kernel de Linux permite modificar el comportamiento del área de intercambio desde el fichero /proc/sys/vm/swappiness. El valor dentro de este fichero controla la forma en la que el kernel maneja el intecambio de datos entre ram y swap. Los posibles valores para este fichero están localizados entre 0 y 100.

Leer más

Vaciar memoria caché en GNU/Linux

El método de funcionamiento de GNU/Linux respecto de la memoria RAM es algunas veces un poco dudoso. Puede que llegue un momento en el que parece que te quedas sin memoria, por que toda está ocupada, pero sin embargo no hay ningún proceso actualmente que la esté comiendo.

shell> free 
                   total        used          free   shared      buffers     cached
Mem:     2065176    1968620      96556          0     200424     413608

Esto, a nivel general, es por que los  procesos ocupan RAM y luego no la liberan completamente, sino que queda en memoria caché. Si el kernel detecta que necesita memoria, éste libera automáticamente la memoria caché y es ocupada por memoria usada.
Desde el kernel 2.6.16 existe la posibilidad de modificar este comportamiento de forma dinámica, gracias al valor de una variable escrita en el fichero /proc/sys/vm/drop_caches. Este fichero es usado por el kernel del sistema para saber el comportamiento que debe tener respecto de la memoria. Sus posibles valores son:

• 0: No se hace nada.
• 1: Libera la memoria caché.
• 2: Libera la memoria de los i-nodos y dentries.
• 3: Libera todo.

Por lo tanto, si lo que queremos es liberar la memoria caché, se deberá escribir el valor 1, tal como sigue.

shell> echo 1 > /proc/sys/vm/drop_caches
shell> free 
                  total          used           free     shared    buffers    cached
Mem:     2065176    1482876     582300             0        220     136676

Leer más