Información blog

Linux, tutoriales, noticias, sistemas, redes y seguridad informática, entre otras cosas.

sábado, 24 de junio de 2017

Cómo poner una marca de agua desde la terminal Linux con Imagemagick

Hoy en día es realmente común ver imágenes de galerías o de blogs con marcas de agua incluidas con el fin de que dichas imágenes no puedan ser redistribuidas, a menos que, en algunos casos, pagues por el derecho de usarlas sin marca alguna, cosa común en algunas webs dedicadas a la distribución de imágenes. El proceso de generación e incrustación de marcas de agua puede que a primera vista a uno le pueda parecer complejo o que sea tarea de una persona con conocimientos de maquetación o diseño gráfico; pero en realidad es mucho más sencillo de lo que parece, o al menos lo es en GNU/Linux. Esto es gracias a una herramienta de manipulación de imágenes muy potente y conocida llamada Imagemagick.

Imagemagick_portada

Imagemagick es un conjunto de utilidades basadas en la terminal que es capaz de mostrar, manipular y convertir imágenes de multitud de formatos, lo hace de ella una utilidad muy versátil y conocida. Dicha herramienta, dependiendo de la distribución que estemos usando no estará instalada por defecto, pero al estar dentro de los repositorios oficiales, es increíblemente sencilla de instalar, pues solamente habría que hacer:

apt-get install imagemagick

Con esto realizado, lo primero que crearíamos sería nuestra marca de agua particular, la cual en nuestro caso sería basada en texto y que sería la que usaríamos para incrustarla a nuestras futuras imágenes. En mi caso particular la marca de agua en sí se llamaría Marca_bytelearning.png pondría bytelearning, pero se podría poner cualquier otro nombre y texto. Para la creación de la marca de agua en sí, solamente requeriríamos de un comando:

convert -size 400x200 xc:none -pointsize 25 -kerning 1 -gravity center -fill black \
-annotate 330x330+0+0 "Bytelearning" -fill white \
-annotate 330x330+2+2 "Bytelearning" Marca_bytelearning.png

Este comando crearía una marca de agua blanca con bordes oscuros; en concreto dicha marca tendría el siguiente aspecto:

marca_de_agua
Marca de agua

Obviamente dicha marcha de agua tendría que ser incrustada en una imagen a nuestra elección y además tendría que tener una pequeña degradación para que la marca de agua sea semi-transparente en la imagen en la que queramos añadir nuestra marca. Esto se logra gracias al comando composite, que tendría la estructura de a continuación:

composite  -disolve 20% -tile marca_de_agua imagen_original nombre_imagen_con_marca

Por ejemplo, si nuestra imagen se llamase prueba_marca.png, el comando podría ser:

composite -dissolve 20% -tile Marca_bytelearning.png \
prueba_marca.png prueba_marca_MARCADO.png

Lo cual daría como resultado una imagen como la siguiente:

tux_marca_de_agua

Si tuviésemos la costumbre de incrustar marcas de agua de manera recurrente, si bien el comando es relativamente sencillo, podemos simplificarlo todo en un script que hará que todo resulte mucho más sencillo. Un script como el siguiente, al que podríamos llamar incrustador_marca.sh:


#!/bin/bash

#VARIABLES COLORES
VERDE='\e[0;32m' #Verde
ROJO='\e[0;31m' #Rojo
NC='\e[0m' # No Color

#COMPROBAMOS LA CANTIDAD DE ARGUMENTOS
if [[ $# -ne 1 ]];
then
        echo -e "${ROJO}SOLAMENTE HAY QUE INTRODUCIR UN ARGUMENTO${NC}"
        exit
fi
#PREPARAMOS LOS COMPONENTES
IMAGEN_ORIGINAL=$1
IMAGEN_MARCADA=$(echo "${IMAGEN_ORIGINAL}" |cut -d '.' -f 1)"_MARCADA.png"
MARCA_AGUA=/tmp/Marca_bytelearning.png

#EJECUTAMOS EL COMANDO
composite -dissolve 20% -tile ${MARCA_AGUA} ${IMAGEN_ORIGINAL} ${IMAGEN_MARCADA}\
> /dev/null 2>&1

#INFORMA DEL RESULTADO DEL COMANDO
if [[ $? -ne 0 ]];
then
        echo -e "${ROJO}La incrustacion de la marcha ha sido FALLIDA" \
        "revise la imagen original: ${NC}${IMAGEN_ORIGINAL}"
else
        echo -e "${VERDE}La incrustacion de la marca ha sido EXITOSA," \
        "revise la nueva imagen: ${NC}${IMAGEN_MARCADA}"
fi

Con esto haríamos que todo el proceso fuese automático, exigiendo a cualquier persona que use el script el mínimo esfuerzo, ya que solamente habría que indicarle la imagen a la que queremos incrustarle la marca.

Gracias a esto, tendríamos un incrustador automatizado y cualquier marca que queramos poner en nuestras imágenes se haría de forma rápida e intuitiva.

Espero que os haya resultado útil.

Saludos.

viernes, 16 de junio de 2017

Cómo cifrar un disco en Linux con LUKS

La seguridad de nuestros datos es cada vez más preocupante para usuarios de todos los niveles, tanto a nivel de equipos de escritorio como de servidores. Es más, a nivel de equipos escritorio es algo aún más importante, ya que dichos equipos están al alcance de cualquiera y si una buena protección nuestros datos pueden verse expuestos. Existen varios tipos de cifrado que suelen estar orientados para cifrar cierto tipo de 'objetos'... Por ejemplo GPG o PGP son usados para el cifrado de ficheros y eCryptfs para el cifrado de directorios... Pero ninguna de estas herramientas de cifrado sirve para nuestro propósito; para cifrar un disco entero tenemos que optar por otro tipo de cifrado llamado LUKS.

LUKS

LUKS (Linux Unified Key Setup) es una especificación de cifrado de disco creado para GNU/Linux que se usa de forma estándar, lo que hace que dicho cifrado pueda ser usado en cualquier distribución de Linux. Dicho cifrado está específicamente pensado para cifrar discos, lo que lo hace perfecto para nuestro propósito.

Para ello lo primero que habría que hacer sería instalar las dependencias necesarias para posibilitar tanto el cifrado como el descifrado del disco, pues si bien es una implementación estándar, algunas distribuciones, tales como Debian, no la instalan por defecto. El paquete en cuestión se llama cryptsetup, el cual se instala desde los repositorios oficiales, lo que es tan sencillo como:

apt-get install cryptsetup

Por otro lado, vamos a tratar con un disco duro 'limpio', que simplemente está conectado; es decir que no tiene contenido alguno, ni tabla de particiones alguna; solamente está conectado. Con lo que vamos a convertir dicho disco duro en un disco duro con cifrado que además se automontará durante el arranque y que estará siempre disponible para nosotros.

Para ello, lo primero que haremos será fdisk, lo cual de por sí es sencillo, si bien en este caso no le agregaremos formato alguno al disco duro que añadamos, solamente le asignaremos una tabla de particiones muy básica para que nuestro sistemas pueda interactuar con él. Nuestro disco en cuestión es /dev/sdb, con lo que lo que haríamos sería:

fdisk /dev/sdb

Tras lo cual simplemente habría que crear una nueva partición, pulsando la tecla n, haciendo que dicha partición ocupe todo el disco, cosa que ya trata de hacer por defecto, y aplicando los cambios al disco en cuestión mediante la tecla w.

fdisk
Muestra comando fdisk

Esto que acabamos de hacer haría que tuviesemos como resultado un disco duro de nombre /dev/sdb con una partición única llamada /dev/sdb1. Generalmente sería necesario darle formato a dicha partición, pero no lo vamos a realizar aún debido a que cuando cifremos la unidad eliminaremos TODO el contenido de ésta y además dejaremos la unidad sin formato, con lo que en caso de tener contenido dentro de la partición, habría que hacer una copia de seguridad antes de pasar a cifrarla.

Teniendo eso en cuenta lo que haremos será cifrar la partición con formato LUKS, lo cual se hará mediante el comando de a continuación:

cryptsetup luksFormat /dev/sdb1

Para verificar que vamos a cifrar dicha partición, lo que tendremos que escribir será YES, tras lo cual nos pedirá que introduzcamos la contraseña con la que descifraremos la partición. El proceso tardará más o menos tiempo dependiendo de la potencia de nuestro equipo y del tamaño de la unidad que queramos cifrar.

Para abrir, o mejor dicho descifrar, la unidad que recién acabamos de crear, necesitaremos usar el comando cryptsetup de nuevo, pero con una estructura diferente:

cryptsetup open nombre_partición nombre_identificativo

Él nombre identificativo sería el nombre con el cual haremos referencia a la partición tras descifrarla. Es decir que tras descifrar la unidad, no haremos referencia a ésta como dev/sdb1 (en este caso) sino cono el nombre identificativo que le hemos asignado.

cryptsetup open /dev/sdb1 DISCO

Tras introducir el comando, el equipo nos pedirá introducir la contraseña correspondiente, tras la cual el disco quedará disponible, si bien no podremos hacer referencia a éste como habitualmente, sino que tendremos que hacerlo a través de su nombre identificativo; además, no encontraremos dicho nombre dentro del directorio /dev/ como es habitual con los dispositivos físicos, sino que lo haremos a través del directorio /dev/mapper. A sabiendas de que el nombre que le hemos puesto es DISCO, la ruta completa de nuestra unidad descifrada será /dev/mapper/DISCO.

Ahora que tenemos localizada la unidad, pasaremos a darle formato para que podamos usarla con normalidad. En este caso le vamos a asignar formato ext4, el más común de todos, pero podemos darle otros tales como bfs, ext2 o ext3. El comando para darle formato ext4 sería:

mkfs.ext4 /dev/mapper/DISCO

Ahora que la unidad tiene formato, ya puede ser usada por el sistema como si fuese una unidad más sin ningún tratamiento especial. Por ejemplo vamos a crear una carpeta llamada /mnt/NUEVODISCO, para luego montar la unidad dentro de ésta:

mkdir /mnt/NUEVODISCO
mount /dev/mapper/DISCO /mnt/NUEVODISCO

Con esto ya tendríamos la unidad disponible y perfectamente utilizable, lo cual generalmente es lo que deseamos, pero el problema que tiene esto es que al reiniciar el equipo habrá que recurrir de nuevo al comando cryptsetup para después montar de nuevo la unidad... Tarea que si bien no es demasiado complicada, si que es algo tediosa tener que hacerla cada vez que arranquemos el equipo, si tenemos intención de tener la nueva unidad siempre disponible.

Es por eso que vamos preparar el equipo para que cada vez que se inicie éste, realice todos los preparativos y que solamente te pida la contraseña de descifrado durante el arranque. Para ello tendremos que dirigirnos al fichero /etc/cryptab; fichero que ha sido creado durante la instalación de cryptsetup y que trabaja de forma parecida a fstab, pero orientado a discos cifrados. Dicho fichero será modificado para acabar con el siguiente aspecto:

# <target name> <source device> <key file> <options>
DISCO    /dev/sdb1       none luks

Gracias a ésto, el disco sería descifrado durante el arranque. Solamente faltaría montarlo para que sea accesible tan pronto como hemos arrancado el equipo, cosa que se especificaría dentro del fichero /etc/fstab. Aquí añadiremos esta línea al final del todo:

/dev/mapper/DISCO /mnt/DISCONUEVO ext4 rw 0 0

Tras aplicar este cambio, únicamente haría falta actualizar initframs (initial RAM file system) para asegurarnos de que descifre y monte adecuadamente nuestra nueva unidad. La actualización radica en un único comando que sería:

update-initramfs -u -k all

Gracias a esto, tras reiniciar el sistema veremos que pide una contraseña para descifrar la nueva unidad, contraseña que tendremos que introducir para poder acceder a ésta. Dicha contraseña siempre será pedida durante cada arranque, pero al menos evitaremos tener que usar cryptsetup y mount tras cada arranque.

Espero que os haya resultado útil.

Saludos.

miércoles, 7 de junio de 2017

Cómo mandar mensajes del Kernel de Linux por red

Una de las prácticas que más miedo le da a uno a la hora de trabajar con GNU/Linux es la actualización del Kernel... Dicha actualización siempre tiene cierta peligrosidad,especialmente si el kernel ha sido compilado a mano, ya que al final estamos metiendo una nuevo núcleo que va a soportar nuevos componentes de hardware, va a solucionar bugs, etc... pero que también puede generar ciertas incompatibilidades y puede tener algún problema con algún módulo o alguna función, llegando a generar, en casos extremos, los temidos 'Kernel panic'. Es por ello que puede ser interesante capturar los mensajes del kernel con el fin de ver la causa de un problema concreto; especialmente el mencionado kernel panic, ya que si hay un kernel panic y el sistema es reiniciado (cosa normal, ya que los pánicos suelen hacer que el ordenador se apague o reinicie), el problema no se registra en ninguna parte y lo único que ven los logs es el kernel panic en sí y no la causa del error. Además, al ser enviados los mensajes a otra máquina, podremos examinarlos tranquilamente pues la maquina receptora, en un principio, será un equipo estable.

Linux_kernel

Para ello lo que habría que tener claro es la esquemática de red que seguiremos... En este caso querremos que los mensajes a otro equipo que se encuentra en la misma red local; en concreto el escenario sería el siguiente:

escenario_transferencia
Escenario transferencia de mensajes del kernel

Con esto claro, lo primero que tenemos que conocer es la MAC del equipo destino, MAC que usaremos más adelante para el envió de mensajes... Esto se puede conocer gracias a la tabla ARP que se puede consultar desde el equipo que va a enviar los mensajes. Para ello simplemente tendremos que usar dos comandos muy sencillos que se pueden usar en una consecución:

ping -c 2 192.168.1.7 && arp -n |grep 192.168.1.7 |awk '{print $3}'

Con el primer comando, haríamos un simple ping al equipo al que queremos transferir los archivos, ping que haría que la IP y la MAC del equipo de destino se agregasen automáticamente a la tabla ARP (siempre y cuando no existiesen ya dichos datos). Con el segundo comando extraeríamos la MAC correspondiente a dicha IP; extracción que realizaríamos de la tabla ARP.

Ahora que conocemos la MAC del destinatario de nuestros mensajes, pasaremos a modificar el arranque del GRUB en el equipo A para que muestre todos los eventos del kernel durante el arranque, acción que realizaremos como root... Esto se puede hacer de dos formas, o de manera temporal o de manera permanente... En este caso lo haremos de forma permanente, para lo cual iremos al fichero /etc/default/grub y editaremos el parámetro GRUB_CMDLINE_LINUX_DEFAULT, borrando su contenido y haciendo que tenga el siguiente aspecto:

GRUB_CMDLINE_LINUX_DEFAULT="debug ignore_loglevel"

Tras dicho cambio, guardaríamos los cambios en el fichero y luego ejecutaríamos el comando:

update-grub

Tras realizar dicho cambio lo que haremos será que un módulo llamado netconsole cargue durante el arranque, dicho módulo permitirá el envío de eventos del kernel a través de la red, con lo que su importancia es fundamental. Para añadir dicho módulo simplemente habría que incluirlo dentro del fichero /etc/modules. Esto consiste simplemente en escribir el comando de a continuación:

echo 'netconsole' >> /etc/modules

Aún así, con la carga de dicho módulo durante el arranque no vale, pues dicho módulo debe tener una configuración, en la que se especifique de donde a donde van a ir los paquetes, la interfaz por la que van a salir y la MAC del destinatario (para evitar posibles malentendidos o posibles ARP spoofing). Para dicha configuración habría que crear el fichero /etc/modprobe.d/netconsole.conf y añadirle lo siguiente:

options netconsole netconsole=10000@192.168.1.6/eth0,10000@192.168.1.7/08:00:27:e0:ad:30

Tal vez así escrito no quede demasiado claro, pero expuesto de forma genérica vendría a ser la estructura:

options netconsole netconsole=puerto_origen@ip_origen/nombre_interfaz_origen,puerto_destino@ip_destino/mac_destino

Es muy importante que todos los datos estén correctos, ya que en caso contrario el módulo no cargará y no podremos enviar los eventos.

Teniendo el emisor preparado, habría que preparar el receptor de dichos mensajes; preparación que afortunadamente no requiere gran esfuerzo; simplemente requiere tener netcat instalado. En caso de no tenerlo instalado haríamos:

apt-get install netcat

Netcat sería usado en este caso para ponernos a "escuchar" en el puerto que hemos especificado anteriormente en netconsole.conf; escucha necesaria para recibir los paquetes que el emisor va a lanzar. Para ponernos en escucha la sintaxis sería:

nc -l -u -p puerto > fichero &

Con esto no solo estaríamos poniéndonos en escucha, sino que además estaríamos almacenando lo recibido en un fichero y con el símbolo & al final estaríamos haciendo que el proceso corriese en segundo plano para que la consola no se sature con mensajes constantemente y para que simplemente leamos los susodichos cuando queramos. En este caso, al haber escogido el puerto 10000 lo que escribiríamos sería:

nc -l -u -p 10000 > /root/192.168.1.6_kernel.log &

Ahora, con tan solo reiniciar el equipo emisor, éste empezaría a mandar eventos; eventos que serían desde los generados en el propio arranque hasta cualquier evento generado por el kernel mientras el equipo está en marcha; gracias al comando anterior, la consola del receptor no se encontraría saturada de mensajes constantemente, sino que solamente tendríamos que consultar el fichero donde estamos volcando los susodichos... Al ser un fichero que suele recibir información con regularidad, lo ideal sería ver tanto el contenido de por sí añadido como el que se va añadiendo en tiempo real, con lo que la mejor forma de consultarlo sería mediante el comando:

tail -n 100 -f /root/192.168.1.6_kernel.log

A modo de ejemplo, nos podríamos encontrar con el contenido de a continuación:

muestra_netconsole
Ejemplo mensajes del kernel

Los mensajes serían exactamente los mismos que los que mostraría el equipo emisor si introdujésemos en éste el comando dmesg, con la ventaja de que en caso de reiniciar el equipo, no perderíamos la información generada.

Como podéis ver, los mensajes del kernel pueden ser enviados por red con facilidad, mensajes que más adelante pueden ser analizados con tranquilidad para poder ver la causa los problemas, en caso de haberlos.

Espero que os haya resultado útil.

Saludos.

viernes, 2 de junio de 2017

Cómo crear una autenticación básica en Apache2

Los servidores web están a la orden del día y son cada vez más usados en todo el mundo, ya sea para una web corporativa, una herramienta online o un blog... Existen multitud de servidores webs que pueden alojar dichas páginas, pero sin lugar a duda hay uno de ellos que destaca entre el resto por su popularidad; popularidad que si bien hoy en día ha bajado un poco debido a Nginx, sigue siendo muy alta: Apache2. A veces necesitamos que poner pequeñas restricciones a nuestra página web; restricciones que no guarden cosas de demasiada importancia, pero que tampoco queremos que estén accesibles a todo el mundo... Es por eso que vamos a ver cómo crear una autenticación básica para páginas web alojadas en un servidor Apache2.


APACHE2_LOGO


Obviamente, habría que tener que Apache2 instalado primero (en caso de no tenerlo ya instalado) lo cual afortunadamente es extremadamente sencillo gracias a que el paquete se encuentra incluido entre los repositorios oficiales.

apt-get install apache2

Este proceso es puramente automático con lo que para que Apache2 funcione en sí, no habría que hacer nada más y podemos usar la página de prueba que la instalación ofrece por defecto para comprobar el correcto funcionamiento de nuestra autenticación. Ahora tocaría crear un fichero de autenticación que valide el/los usuarios que nosotros queramos; dicho fichero puede ser almacenado en cualquier parte, pero lo recomendable es que se encuentre dentro del directorio /etc/apache2; El comando que crearía el fichero de autenticación sería htpasswd y si deseásemos que se autenticase a un usuario llamado ivan, haríamos:

htpasswd -c /etc/apache2/.htpasswd ivan

Al introducir el comando nos pediría contraseña, contraseña que tendremos que utilizar más adelante para autenticarnos al acceder nuestra página web, con lo que es conveniente recordarla. Si deseásemos añadir más usuarios a dicho fichero, tendríamos que usar el mismo comando pero sin el parámetro -c; es decir que por ejemplo para añadir el usuario invitado, haríamos:

htpasswd /etc/apache2/.htpasswd invitado

Se pueden añadir tantos usuarios como queramos hasta que cubramos nuestras necesidades. Una vez hayamos preparado todos los usuarios, tendremos que editar el host virtual de Apache2 para que requiera de autenticación antes de acceder la web... El host virtual por defecto se configura en el fichero /etc/apache2/sites-enabled/000-default.conf, y ese será el fichero que editaremos para que tenga el aspecto de a continuación:

  1. <VirtualHost *:80>
  2.         ServerAdmin webmaster@localhost
  3.         DocumentRoot /var/www/html
  4.         <Directory "/var/www/html">
  5.             AuthType Basic
  6.             AuthName "Es necesario autenticarse"
  7.             AuthUserFile /etc/apache2/.htpasswd
  8.             Require valid-user
  9.         </Directory>
  10.         ErrorLog ${APACHE_LOG_DIR}/error.log
  11.         CustomLog ${APACHE_LOG_DIR}/access.log combined
  12.         RewriteEngine on
  13.         RewriteRule ^ https://%{SERVER_NAME}%{REQUEST_URI} [L,QSA,R=permanent]
  14. </VirtualHost>

La parte marcada en rojo sería la parte añadida, pero es importante tener controlado todo el contenido del fichero en sí con el fin de que no quede ningún parámetro suelto.

Luego únicamente tendremos que reiniciar el servicio web para aplicar los cambios:

/etc/init.d/apache2 restart

Tras el reinicio solamente quedaría pasar a probar dicha autenticación, cosa tan simple como acceder a la web normalmente... En dicho momento, antes de poder ver nada, veremos una pantalla de login en el navegador en el que se nos pedirá la contraseña:

Contraseña_web

Con tan solo introducir las credenciales correctas, accederíamos a la web con normalidad, habiendo conseguido un proceso de autenticación web práctico y sencillo; obviamente este método es bastante rudimentario, pero al menos nos serviría para tener unas políticas de seguridad básicas.

Espero que os haya resultado útil.

Saludos.