INSTALAR OPENVPN CON AUTENTIFICACIÓN PAM EN RASPBERRY

En anteriores tutoriales instalamos y configuramos un servidor "OPENVPN" mediante certificados digitales.
El problema que esto supone es que las claves y certificados pueden caer en manos ajenas.
En caso de que pase esto, podemos revocar los certificados del cliente para que no pueda acceder.
Nos situaremos en el directorio en donde los creamos y ejecutamos el siguiente script:

$ cd /etc/openvpn/2.0/
$ sudo . ./vars
$ sudo ./revoke-full certificado_usuario

Sin embargo nosotros añadiremos una capa más de seguridad en nuestra comunicación en caso de robo o pérdida de dispositivo.
Trataremos de autentificar la conexión VPN mediante usuario y contraseña a través del módulo PAM, con lo que nos podremos conectar con cualquier usuario local de la Raspberry.

En este sentido tendremos dos opciones:

• Conectarnos con autentificación de usuario/contraseña y certificado del cliente.
• Conectarnos con autentificación de usuario/contraseña sin certificado del cliente.

AUTENTIFICACIÓN CON CERTIFICADO DEL CLIENTE

En el primer caso, que es el que estábamos siguiendo en el anterior tutorial, deberemos modificar ciertos parámetros en los archivos de configuración del servidor y del cliente.
En nuestra Raspberry, abrimos el archivo de configuración del servidor:

$ sudo nano /etc/openvpn/server.conf

Añadimos la siguiente línea:

plugin /usr/lib/openvpn/openvpn-auth-pam.so login

Lo que hacemos es activar el "plugin" para que "OPENVPN" pueda conectar con "PAM".

Reiniciamos el servicio para que se efectuen los cambios:

$ sudo /etc/init.d/openvpn restart

Ahora pasaremos a configurar el cliente:

$ sudo client.opvpn

Agregamos al final del archivo:

auth-user-pass

Con estos sencillos pasos, el servidor, a parte de requerir el certificado del cliente, nos pedirá las credenciales de algún usuario local para autentificar la identidad.

AUTENTIFICACIÓN SIN CERTIFICADO DEL CLIENTE

Para esta segunda opción, editaremos el archivo de configuración del servidor:

$ sudo nano /etc/openvpn/server.conf

Y añadiremos:

client-cert-not-required # No requerimos certificados de los clientes username-as-common-name # El servidor utiliza el nombre de usuario para autentificar. tmp-dir "/etc/openvpn/tmp/" # Directorio temporal para la autentificación. plugin /etc/openvpn/openvpn-auth-pam.so login

Debemos crear el directorio temporal "tmp" para la autentificación ya que por defecto no existe:

$ sudo mkdir /etc/openvpn/tmp

Reiniciamos el servicio:

$ sudo /etc/init.d/openvpn restart

La configuración del archivo cliente la dejamos tal y como lo habíamos configurado en la primera opción, solo añadiendo:

auth-user-pass

CONTROL DE ACCESO A USUARIOS VPN

Si queremos controlar el acceso de los usuarios que se conectan a la VPN, haremos otras modificaciones mas profundas.
Crearemos un archivo de servicio "PAM" dedicado a la autentificación "OPENVPN" para que solo puedan conectar los usuarios que pertenezcan al grupo "vpn".

Primero crearemos el grupo sistema:

$ sudo addgroup vpn

A continuación añadiremos a los usuarios y le asignamos "vpn"  como grupo principal:

$ sudo  useradd usuario_vpn -M -s /bin/false -g vpn

Le asignamos una contraseña:

$ sudo passwd usuario_vpn

Ahora crearemos un archivo de configuración "PAM" para el servicio "OPENVPN":

$ sudo nano /etc/pam.d/openvpn

Agregamos los siguientes módulos:

auth    required        pam_unix.so    shadow    nodelay auth    requisite       pam_succeed_if.so user ingroup vpn quiet account required        pam_unix.so

El primer módulo le solicita al usuario una contraseña y luego verifica la contraseña usando la información almacenada en "/etc/passwd" y, si existe, en "/etc/shadow".
El siguiente módulo comprueba el requisito en el cual el usuario debe pertener al grupo "vpn" para validar la autentificación.
El módulo de la línea 3 verificará si la cuenta ha expirado o si el usuario no ha cambiado la contraseña.

A continuación solo tenemos que editar el archivo de configuración y añadir la nueva ruta para conectar con "PAM":
$ sudo nano /etc/openvpn/server.conf

Modificamos esta línea:
plugin /usr/lib/openvpn/openvpn-auth-pam.so openvpn

Reiniciamos "OPENVPN" para que los cambios surtan efecto:

$ sudo /etc/init.d/openvpn restart

A partir de ahora, solo los usuarios que pertenezcan al grupo "vpn" podrán validarse en el servidor.

Y eso es todo. Si tienes alguna inquietud o duda, puedes contactar conmigo o dejar un comentario al respecto.

Saludos...

INSTALAR OPENVPN MEDIANTE CERTIFICADOS X.509 EN RASPBERRY Pt.2

En este tutorial seguiremos con la configuración de "OPENVPN" en los clientes Windows y Android.

Como comentábamos en la primera parte del tutorial, los certificados y claves se han guardado en la carpeta "/etc/openvpn/2.0/keys/". No hace falta decir que éstos tienen que alojarse en un lugar seguro, con los permisos restrictivos y asegurarlos con una "passphare".

Para configurar nuestros clientes, necesitaremos los siguientes archivos:

• ca.crt: Certificado público de la Autoridad Certificadora.
• usuario1.crt : Certificado público del cliente.
• usuario1.key: Clave privada del cliente.
• ta.key: Clave de autentificación TLS.

Estos lo podremos copiar de la forma que creamos oportuna (pendrive, SCP,SFTP,...) para exportarlos en los dispositivos que utilicemos para la "VPN".

INSTALACIÓN EN WINDOWS

Lo primero que debemos hacer es descargar e instalar el cliente Windows desde https://openvpn.net/index.php/open-source/downloads.html.
Una vez instalado nos dirigimos al directorio donde hemos instalado "OPENVPN" (Archivos de programa/openvpn).
En la carpeta "sample-config" veremos diferentes archivos a modo de ejemplo de configuración (client, server,...).

Copiaremos el archivo "client.ovpn" y lo trasladaremos a la carpeta "config". Es aquí también donde tenemos que copiar los certificados y claves necesarias para el cliente.

Editaremos el archivo de configuración "client.opvn" y dejamos las siguientes líneas:

client # Declaramos que se trata de un cliente. dev tun # Interface virtual que utilizaremos. proto udp # Protocolo usado. remote ip_pública 1194 # Nuestra ip pública mas el puerto de acceso. resolv-retry infinite # Trata de resolver infinitas veces la conexión con el servidor. nobind # No es necesario usar siempre el mismo puerto local de origen para iniciar la #conexión. persist-key # Preserva la clave usada ante reinicio para no tener que volver a leerla. persist-tun # Mantiene la interfaz TAP levantada si hay un reinicio de la VPN. # Ruta de los certificados: ca ca.crt cert usuario1.crt key usuario1.key remote-cert-tls server # Comprobacion del certificado TLS en el servidor. tls-auth ta.key 1 # Clave de autentificacion TLS. comp-lzo # Habilitar la compresion en el tunel VPN. redirect-gateway def1 # Redirigimos todo el trafico a traves de la VPN. verb 3 # nivel de informacion que se guardara en el archivo log.

Una vez guardado el archivo, pasaremos a probar el correcto funcionamiento del programa.

Abrimos el ejecutable desde "Inicio > Todos los programas > OpenVPN > OpenVPN GUI". Es importante abrirlo como administrador porque sin privilegios no podremos conectarnos a la red interna de la VPN.
Aparecerá un pequeño icono en la parte inferior derecha con el que podremos conectarnos:

Procedemos a verificar que conecta correctamente y nos asigna una ip dentro de la subred fijada para los clientes vpn.

De esta forma podremos ya acceder a nuestra red interna sin problemas.

INSTALACIÓN EN ANDROID

Lo primero que debemos hacer es instalar desde Playstore un cliente compatible, como por ejemplo "OPENVPN Connect for Android".

Una vez instalada la aplicación crearemos un archivo de configuración  rellenando los mismos datos que vimos en el cliente Windows, o simplemente copiando el archivo "client.opvpn" en la carpeta que deseemos del dispositivo móvil.

En esta carpeta agregamos también los certificados y claves para el cliente.

Abrimos la aplicación y pinchamos en "import" para importar la carpeta que contiene el archivo de configuración, los certificados y las claves:

En el siguiente paso seleccionaremos "import Profile from SD card":

Por último pulsamos en connect y esperamos a que se validen los certificados y las claves configuradas:

Si la conexión es satisfactoria observaremos que estamos conectados a la "VPN" y que se nos ha asignado una ip dentro de la  subred 10.8.0.0/24.

En el siguiente tutorial veremos como configurar "OPENVPN" por compartición de claves privadas.

Hasta una nueva entrada....

INSTALAR OPENVPN MEDIANTE CERTIFICADOS X.509 EN RASPBERRY Pt.1

“Openvpn” es un programa “open source” para la creación de túneles seguros VPN (Virtual Private Network). Este no se basa en el protocolo IPsec como en la mayoría de las VPN, sino que se sustenta en el protocolo TLS/SSL.
Su objetivo principal es proporcionar los servicios de autentificación, confidencialidad e integridad.
Pero, ¿para que nos puede servir en nuestra Raspberry?. Pues por ejemplo para que nuestra navegación sea anónima si nos conectamos a una red pública, o también para poder acceder a un recurso compartido o servicio que se encuentre en nuestra red doméstica.
Utilizaremos en este caso el modo "Host to LAN", donde los clientes se pueden conectar de forma independiente desde el exterior al servidor, y éste los conectará a nuestra red privada de casa por medio de una interface virtual ("tun0"). Toda la comunicación entre cliente y servidor está encriptada a través del túnel.

OpenVPN se basa en OpenSSL para implementar SSL/TLS, y soporta dos modos de autentificación:

• Por compartición de claves privadas (más sencilla y menos segura a la vez). Modo que veremos en próximos tutoriales.
• Por certificados digitales con estándar X.509 (más compleja pero más segura). Esta será la opción que veremos en el tutorial.

Para empezar, instalamos el programa:

$ sudo apt-get install openvpn

Lo primero que haremos será crear todos los certificados:

• ca.crt: Este es el certificado público de la CA, que tendremos que usar en todos los clientes y en el servidor.
• servidor.crt y servidor.key: Certificado público y privado del servidor. Solo los usaremos en el este.
• dh2048.pem: Contiene los parámetros Diffie-Hellman que se ubicarán sólo en el servidor.
• usuario1.crt y usuario1.key: Certificados público y privado del usuario que utilizaremos para configurarlo  en su dispositivo.

OpenVPN proporciona unos archivos de ejemplos que nos servirán de ayuda para configurar de manera cómoda el servicio VPN ubicada en "/usr/share/doc/openvpn/examples".

Copiaremos el directorio de creación de certificados a nuestro directorio principal de configuración:

$ sudo cp -r /usr/share/doc/openvpn/examples/easy-rsa/2.0 /etc/openvpn/

Para crear ahora nuestra propia autoridad certificadora CA con RSA editaremos el archivo "vars" y modificamos las últimas líneas:

$ sudo nano /etc/openvpn/2.0/vars

En este archivo también otros aspectos importantes cómo el tiempo de expiración del certificado, el tamaño de la clave RSA,...

Para crear un mayor seguridad, modificaremos el tamaño de la clave de 1204 a 2048 bits. Buscamos la línea correspondiente y la modificamos:

Ahora exportaremos los datos introducidos en vars:

$ cd /etc/openvpn/2.0

$ sudo su

# source ./vars

Debemos comprobar y eliminar que no haya otros archivos en la carpeta "keys" para evitar un posible conflicto:

# ./clean-all

Ya que tenemos todo preparado. Iremos creando los diferentes certificados para adaptarlos a la configuración de "OPENVPN".

Primero crearemos las claves de la Autoridad Certificadora "CA":

# ./buil-ca

Veremos como se nos ha creado la carpeta "keys" con el primer certificado y clave:

Seguiremos los mismos pasos para la creación  del certificado "Diffie-Hellman":

# ./build-dh

Sólo nos quedará crear las claves del servidor y los clientes que se conectarán a él:

# ./build-key-server raspberrypi2

#  ./build-key usuario1

Rellenamos los campos como cuando creamos la CA. Nos pedirá si queremos poner una "passphrase" para resguardar el archivo, y posteriormente lo autofirmaremos.

Si queremos aumentar la seguridad de la comunicación, crearemos otra clave que se instalará en el servidor y los clientes respectivamente. Esto permitirá el uso de la autentificación TLS a través de firmas HMAC para verificar la integridad de los paquetes transmitidos entre el cliente y servidor. Así evitaremos ataques de Denegación de Servicios (DoS), ataques "Man in The Middle",...

Accederemos a la carpeta "keys" y aplicamos el siguiente comando:

$ sudo cd /etc/openvpn/2.0/keys
$ sudo openvpn --genkey --secret ta.key

Se nos generará una llave estática que copiaremos en el directorio principal y que después configuraremos en el archivo "server.conf":

$ sudo mv ta.key /etc/openvpn/

Una vez obtenidos los diferentes certificados y claves solo nos falta integrarlos al archivo de configuración de "OPENVPN".

El archivo de configuración por defecto no existe, por lo que exportaremos el  archivo estándar del directorio de ejemplos y lo descomprimimos:

# cp /usr/share/doc/openvpn/examples/sample-config-files/server.conf.gz /etc/openvpn/

# gunzip /etc/openvpn/server.conf.gz

Abrimos el archivo:

# nano /etc/openvpn/server.conf

Modificaremos las siguientes líneas:

local 192.168.0.101 # Definimos el servidor de escucha. dev tun # Interface virtual por el que se creara el túnel. proto udp # Protocolo que utilizaremos para la conexión. port 1194 # Puerto de escucha. ca /etc/openvpn/2.0/keys/ca.crt # Certificado CA. cert /etc/openvpn/2.0/keys/raspberypi2.crt  # Certificado del servidor . key /etc/openvpn/2.0/keys/raspberrypi2.key # Clave privada del servidor. dh dh2048.pem # Certificado Diffie Hellman. server 10.8.0.0 255.255.255.0 # Definimos la subred en la cual la Raspberry asignara las #distintas ips a los clientes VPN. ifconfig-pool-persist ipp.txt # Logs que contendra el registro de las ip de los clientes que se #conecten. push “route 192.168.0.0 255.255.255.0”  # Permite al cliente conectarse a la red interna por la interface "tun0". push “dhcp-option DNS 8.8.8.8" # Definimos los servidores a través de la cual los clientes #realizarán sus peticiones DNS. client-to-client # Permite a los clientes verse entre sí. tls-auth ta.key 0 # Clave para a la autentificación TLS max-clients 5 # Número máximo de clientes que se pueden conectar de forma #simultanea.

Reiniciamos el servidor para que nuestra configuración surta efecto:

# sudo /etc/init.d/openvpn restart

Si no nos devuelve ningún error, pasaremos a la configuración del enrutamiento para que los clientes puedan acceder a nuestra subred.
Lo primero que debemos hacer es activar el bit "ip forwarding" para que nuestra Raspberry actúe como router y pueda reenviar los paquetes que pasan a través de él.

Editamos el siguiente archivo:

$ sudo nano /etc/sysctl.conf

Descomentamos la siguiente línea:

net.ipv4.ip_forward=1

En nuestro caso, tenemos instalado "UFW" como firewall por lo que editaremos:

$ sudo nano /etc/ufw/sysctl.conf

Modificamos el parámetro:

net/ipv4/ip_forward=1

El siguiente paso será configurar las reglas de tráfico para que sea enrutado de manera correcta.

Abrimos el archivo:

$ sudo nano /etc/default/ufw

Modificando esta línea habilitamos la política del firewall para que acepte por defecto los reenvíos de paquetes:

DEFAULT_FORWARD_POLICY="ACCEPT"

A continuación vamos a añadir la reglas "UFW" adicionales para la traducción de direcciones de red y el enmascaramiento de los clientes VPN:

$ sudo nano /etc/ufw/before.rules

Introducimos esta configuración justo después de esta línea:

# Don't delete these required lines, otherwise there will be error # NAT table rules *nat :POSTROUTING ACCEPT [0:0] # Permitir el tráfico VPN a través de la interface etho0 -A POSTROUTING -s 10.8.0.0/8 -o eth0 -j MASQUERADE COMMIT

Por último crearemos una regla para abrir el puerto UDP 1194, que es el que utiliza por defecto "OPENVPN":

$ sudo ufw allow 1194/udp

Desactivamos y activamos el cortafuegos para que cargue las modificaciones que hemos hecho:

$ sudo ufw disable
$ sudo ufw enable

Ya tenemos nuestro servidor VPN listo. Solo nos queda la configuración en los clientes.
Pero eso será en nuestro próximo tutorial, donde configuraremos los clientes en Windows y Android.

Hasta luego.....

PROTEGER NUESTRA RASPBERRY CON JAIL2BAN Pt.2

En el anterior tutorial vimos como configurar "JAIL2BAN" de una forma básica para evitar ataques de fuerza bruta sobre el protocolo "SSH".
Hoy nos adentraremos un poco más en el funcionamiento de este programa, integrándolo en el cortafuegos "UFW" y creando una jaula desde cero para "OPENVPN".

Cuando baneamos  cualquier ip a través de "JAILBAN", este crea una regla en "iptables" para denegar el acceso a dicha ip mediante una acción. La acción por defecto que utiliza el programa se encuentra en el archivo "/etc/fail2ban/action.d/iptables-multiport.conf" Si, como es mi caso, tenemos instalado el programa "UFW", estas reglas no se ven reflejadas en el propio programa.
Para solucionar el problema crearemos un archivo que contenga las acciones personalizadas para  "UFW" para la jaula "OPENVPN":

$ sudo nano /etc/fail2ban/action.d/ufw-openvpn.conf

Añadiremos las siguientes líneas:

[Definition] actionstart = actionstop = actioncheck = actionban = ufw insert 1 deny from <ip> to any port 1194 # Definimos la acción de baneo para que deniege el acceso a la ip a través del puerto 1194 como primera regla. actionunban = ufw delete deny from <ip> to any port 1194 # Declararamos la acción de desbaneo para que borre la regla descrita en "actionban".

Lo siguiente será determinar los filtros que utilizará "FAIL2BAN" para activar las acción de baneo. Por tanto, crearemos un nuevo archivo en "/etc/fail2ban/filter.d/", que es el directorio donde se encuentra todos los filtros del programa:

$ sudo nano /etc/fail2ban/filter.d/openvpn.conf

Añadimos estos parámetros:

[INCLUDES] before = common.conf [Definition] _daemon = openvpn # Definimos el demonio # Declaramos el filtro de fallo con la ayuda de la expresiones regulares failregex = <HOST>:[0-9]{4,5} TLS Auth Error: Auth Username/Password verificatio                                                                             n failed for peer ignoreregex =

Una vez guardado, solo nos queda configurar nuestra jaula:

$ sudo nano /etc/fail2ban/jail.conf

Añadimos al final del archivo:

[openvpn] enabled = true # Activamos la jaula. port = 1194 # Señalamos el puerto  protocol = udp # Indicamos el protocolo  filter = openvpn # Declaramos la ruta del archivo del filtro que configuramos en #/etc/fail2ban/filter.d/openvpn.conf banaction = ufw-openvpn # Archivo que contiene las acciones que añadimos en #/etc/fail2ban/action.d/ufw-openvpn. logpath = /var/log/openvpn.log # Ruta donde se encuentra los logs de registro en el cual se #aplicarán los filtros. maxretry = 3 # Numero maximo de intentos de acceso.

Ya tenemos lista nuestra jaula para "OPENVPN".

Para probarla, monitorizamos los logs de "FAILBAN":

$ sudo tail -f /var/log/fai2ban.log

Intentaremos acceder desde cualquier pc o dispositivo con credenciales erróneas.
Tras tres intentos fallidos, veremos reflejados en el archivo log como se ha baneado la ip:

Si también nos fijamos en "UFW", una nueva regla se ha añadido en la tabla, denegando el acceso a la ip del dispositvo al puerto 1194.

Si queremos desbanear la ip, solo tendremos que borrar dicha regla.

$ sudo ufw delete 1

En este tutorial hemos adquirido los conocimientos suficientes para crear nuestra propia jaula, aplicar nuestros propios filtros y acciones para evitar los ataques de fuerza bruta hacia los servicios más críticos de nuestra red doméstica.
Un saludo...

PROTEGER NUESTRA RASPBERRY CON JAIL2BAN Pt.1

Uno de los principales problemas al exponer nuestra Raspberry al exterior es la vulnerabilidad a través de los puertos de comunicación. Los ataques de fuerza bruta actúan contra los servicios de un servidor (ssh, ftp,..), y pueden ocasionar que un hacker pueda acceder a nuestras credenciales (nombre/password), probando todas las combinaciones posibles. 
Por eso es importante restringir el número de intentos de acceso fallidos a un servicio desde cualquier dispositivo.

"FAIL2BAN" es un programa que nos ayudará a prevenir estos ataques de forma sencilla. Su misión consiste en filtrar un archivo de registro con una expresión regular el cual notificó una prohibición de acceso a cierto servicio del sistema. Dependiendo del número de intentos fallidos, el programa creará una regla en "iptables" denegando el acceso a esa ip por el puerto del servicio afectado. Una vez transcurrido el tiempo de baneo indicado, "FAIL2BAN" eliminara esta regla "iptables".

Lo primero será instalar el programa:

$ sudo apt-get install fail2ban

Cuando la instalación haya terminado, Nos tocará editar los diferentes archivos de configuración:

• /etc/fail2ban/jail2ban.conf: Archivo general donde podemos definir la ruta de los logs, configurar el socket para activar el demonio,...
• /etc/fail2ban/jail.conf: Es el archivo más importante, ya que es aquí donde se configura las jaulas de los servicios, tiempo máximo de intentos, el tiempo de baneo,..
• /etc/fail2ban/action.d/: Directorio están los archivos en el que se definen las acciones que se van a utilizar de forma predeterminada o en cada unos de los servicios definidos.
• /etc/fail2ban/filter.d/: Directorio que contiene los archivos donde se definen los patrones que fail2ban buscará en el archivo log definido en cada servicio para activar las acciones.

Por defecto, al instalar "FAILBAN", éste ya cuenta con una configuración por defecto que nos servirá cómo punto de partida para ir perfilando la nuestra propia.

En nuestro primer ejemplo activaremos "FAILBAN" para el servicio "SSH".

Abriremos el archivo de configuración de las  jaulas:

$ sudo nano /etc/fail2ban/jail.conf

Modificaremos las siguientes líneas generales:

ignoreip = 127.0.0.1/8 # Ignoramos los intentos fallidos desde localhost. bantime  = 18000 # Tiempo de baneo por defecto en segundos. maxretry = 3 # Máximo de intentos fallidos por defecto. action = %(action_mwl)s # acción por defecto con la opción "wl" que enviará un mail de #alerta. destemail = usuario@gmail.com # Email al que se mandará las notificaciones de alerta.

 Dentro de las jaulas modificaremos el servicio "ssh":

[ssh] # Nombre de la jaula enabled  = true # Activación por booleano. port     = 22 # Puerto de escucha de "SSH". filter   = sshd # Archivo de filtro que está ubicado en /etc/fail2ban/filter.d. logpath  = /var/log/auth.log # Archivo log donde se aplicará el filtro.

Ya tendremos configurado "FAIL2BAN" para el servicio "SSH". Sólo nos falta reiniciar el servicio y probar su funcionamiento:

$ sudo /etc/init.d/fail2ban restart

Una vez reiniciado, monitorizamos a tiempo real el archivo log del programa:

$ sudo tail -f /var/log/fail2ban.log

Intentaremos ahora  acceder mediante cualquier dispositivo mediante "SSH" a nuestra Raspberry con credenciales erróneas.

Tras los tres intentos que hemos definido anteriormente, "FAILBAN" baneara la ip del dispositivo:

Transcurrido el tiempo que hemos especificado, el programa desbaneará la ip:

También se nos notificara por mail las acciones de baneo del dispositivo que intentado acceder, tal y como habíamos configurado en el archivo "jail.conf" :

Como hemos podido observar, hemos configurado "JAILBAN" para que evitar que cualquier intruso pueda dirigir una ataque de fuerza bruta al servicio "SSH".

En el próximo tutorial integraremos el cortafuegos "UFW" con "FAILBAN", y crearemos una jaula para el servicio "OPENVPN" desde cero.

Hasta otra....

INSTALAR SSMTP EN RASPBERRY PI 2

"SSMTP" es una herramienta "sendmail" muy útil si no disponemos de un servidor MTA local (Linux Mail Transfer Agent), ya que actuará como un "smpt relay" que reenviará los correos de nuestra Raspberry a una cuenta externa Gmail. Si queremos, por ejemplo, que nuestros scripts manden notificaciones via e-mail de manera sencilla, el programa "SSMTP" nos servirá como instrumento para reenviar todo el correo que queramos a un servidor "SMPT" externo.

Instalaremos el paquete "SSMTP" y además un conjunto de herramientas para mandar correos desde la línea de comandos, que nos servirá como "testeo" de la aplicación:

$ sudo apt-get install mailutils ssmtp

Una vez instalados, abriremos el archivo de configuración:

$ sudo nano /etc/ssmtp/ssmtp.conf

Borramos el contenido y añadimos los siguientes parámetros:

root=usuario@gmail.com # especificamos la cuenta reenviadora.  mailhub=smtp.gmail.com:587 # servidor y puerto servidor de correo Gmail hostname=nombre de la Raspberry # hostname de nuestra Raspberry AuthUser=usuario de Gmail # usuario de la cuenta reenviadora AuthPass=contraseña # password de la cuenta reenviadora # permitimos el protocolo de comunicación seguraTLS/SSL UseTLS=Yes  UseSTARTTLS=YES  FromLineOverride=YES

Guardado el archivo, asignaremos los permisos oportunos. Debemos ser muy precavidos porque la contraseña de nuestra cuenta Gmail está en texto plano y sin un mínimo de seguridad cualquiera podría acceder a ella. Por eso, tenemos que tener muy claro quién va a acceder al archivo y qué usuarios van a poder mandar emails.
En mi caso, otorgaré el control total al usuario "root" y permiso de lectura al grupo "adm" (administradores del sistema):

$ sudo chown root:adm /etc/ssmtp/ssmtp.conf
$ sudo chmod 740 /etc/ssmtp/ssmtp.conf

También podemos crear un alias para que los usuarios locales puedan reenviar mails. Para configurar cada uno editamos el archivo "revaliases":

$ sudo nano /etc/ssmtp/revaliases

# sSMTP aliases # # Format:       local_account:outgoing_address:mailhub # # Example: root:your_login@your.domain:mailhub.your.domain[:port] # where [:port] is an optional port number that defaults to 25. usuario_local:usuario@gmail.com:smtp.gmail.com:587

Con esto podemos asociar un usuario local a nuestra cuenta de gmail.

Una vez configurado todo, tendremos dos opciones probar la aplicación:

• Mandando un correo a través del comando "mail" que instalamos con "mailutils": 

         $ sudo echo "esto es una prueba" | mail -s Prueba destinatario@gmail.com

• Enviando un mail por medio del comando "ssmtp":

         $ sudo ssmtp destinatario@gmail.com

         

    Donde detallamos el asunto:

          Subject: esto es una prueba desde consola

          Pulsamos "enter" e introducimos el cuerpo del mensaje:

          Prueba desde Raspberry

          Para mandarlo solo tenemos que pulsar "ctrl + d".

         

Verificamos que nuestro mail se ha enviado correctamente desde el registro del sistema:

$ sudo cat /var/log/syslog

Hay que tener en cuenta que por defecto Google puede bloquear los intentos de inicio de sesión a nuestro correo de reenvío desde un dispositivo que no utilice sus estándares de seguridad. Para evitar esto accedemos al enlace https://www.google.com/settings/security/lesssecureapps y pinchamos en "activar" en "acceso de aplicaciones menos seguras:

Con todo esto, ya podremos enviar mails de notificaciones o alertas automáticamente a través de nuestros scripts desde nuestra Raspberry a cualquier dirección de correo que deseemos...