Postfix - Configurando un servidor de correo en debian / raspberry pi

La mayor parte de las instrucciones de este artículo están extraídas del magnífico artículo de Sam Hobbs y que forma parte de una serie más completa de instalar un servidor de correo completo con servidor web etc.

Requerimientos

En mi caso sólo pretendo configurar mi Rasberry Pi para que sea capaz de enviar correos electrónicos y recibir algunos correos electrónicos en las cuentas de usuario o reenviarlos a cuentas exteriores. ¿no me explico bien? A ver si así:

• Quiero poder enviar correos electrónicos desde las cuentas de usuario (como "pi") y desde algunas programas como el fail2ban o el php.
• Los correos que se reciban para ciertos usuarios (como "pi") estarán disponibles al loguearse por ssh.
• Quiero que existan ciertas direcciones virtuales (como gonzalo@zoogon.net) que cuando reciban correo lo reenvíen directamente a mi cuenta de gmail.
• Las cuentas de correo NO serán accesibles por pop3 ni imap, para eso hace falta más software. Accederé directamente desde la línea de comandos.
• Quiero que la instalación esté protegida para que nadie pueda hacer envíos de correo desde este servidor.

Prerrequisitos

Debes disponer de un dominio propio. En mi caso lo he contratado con NameCheap y las pantallas de configuración que mostraré serán las de ellos. Otros servicios de dominio deberían servirte igual mientras te permitan crear subdominios y especificar si los registros son tipo A, txt y registros MX (date una vuelta por este artículo si no sabes de lo que estoy hablando)

Lo normal sería que tu Raspberry Pi esté configurada con una ip fija detrás de un router. Asegúrate de que tienes redirigido el puerto 25 del router a la RPi. Si además tu ip externa es dinámica (lo que sería normal) puedes utilizar el cliente ddclient para mantener tus registros DNS actualizados (ejemplo con namecheap y raspberry pi)

Con sudo hostname nombre-maquina.dominio.com establece el nombre de tu máquina. (debe ser completo o fqn) Deberías verlo actualizado en /etc/hostname

$ cat /etc/hostname 

rpi.midominio.net

Preparando los dominios

En tu registrador de DNS tiene que ofrecerte la posibilidad de configurar a qué servidores mail tiene que vincular los correo midominio.net. En mi configuración puedes ver que tengo definidos dos subdominios rpi y mail del tipo A (que corresponden con una dirección). En realidad, para mi caso ambos dominios están vinculados a la misma máquina pero lo he preparado por si quisiera instalar un segundo servidor de correo para backup.

El registro de subdominio @ con los valores de v=spf1 mx a ~all del tipo TXT Record es importante porque muchos servidores de correo no reconocerán el nuestro como válido si no lo incluimos.

En la parte de definir los servidores de correo lo que estoy indicando con la @ es que para cualquier correo que llegue a mis direcciones debe redirigir el mensaje a mail.midominio.net y en caso de no encontrarlo lo debe hacer  rpi.midominio.net. El valor MX PREF indica la prioridad a la hora de seleccionarlos.

En el artículo de Sam sobre configurar correctamente un DNS tienes unas buenas explicaciones de qué significa cada cosa.

Instalando y configurando postfix

Voy a ir rápido en muchas de las instrucciones.  Te recomiendo que le des un vistazo al artículo que menciono al principio del post si quieres profundizar. La única diferencia es que yo no he llegado a instalar dovecot para acceder por pop3 e imap.

Comienza instalando postfix y las herramientas de mail

$sudo apt-get update && sudo apt-get install postfix mailutils

Te preguntará que tipo de servicio deseas instalar, le decimos que "sitio en internet". Si hemos configurado el hostname correctamente lo cogerá. Tendrás algunos warnings referentes a ipv6, no te preocupes enseguida lo solucionaremos.

Editar /etc/postfix/main.cf y añade lo siguiente al final del archivo

#usar sólo el protoclo ipv4, evitamos mensajes de warning

inet_protocols = ipv4

#establecemos restricciones para que no cualquiera se pueda 

#conectar a nuestra máquina y hacer envíos a direcciones 

#de correo externas

smtpd_recipient_restrictions =

permit_sasl_authenticated,

permit_mynetworks,

reject_unauth_destination

#establecemos unas restricciones en el saludo a la máquina

smtpd_helo_required = yes

smtpd_helo_restrictions =

        permit_mynetworks,

        permit_sasl_authenticated,

        reject_invalid_helo_hostname,

        reject_non_fqdn_helo_hostname,

        reject_unknown_helo_hostname

        check_helo_access hash:/etc/postfix/helo_access

virtual_alias_maps = hash:/etc/postfix/virtual

Puedes ver referencias a dos archivos que vamos a crear. El primero /etc/postfix/helo_access sirve para spammers que pretendan hacerse pasar por nuestras máquinas.  Debería contener los dominios que tenemos registrados para el correo, en mi caso:

midominio.net          REJECT          Get lost - you're lying about who you are

mail.midominio.net     REJECT          Get lost - you're lying about who you are

rpi.midominio.net      REJECT          Get lost - you're lying about who you are

El segundo contendrá los mapeos de direcciones virtuales que queremos introducir

webadmin@midominio.net mi-correo-en@gmail.com

rpi@midominio.net       pi

Esto significa que cualquier correo que llegue a webadmin@midominio.net saldrá rebotado a mi cuenta de gmail. Cualquier correo que llegue a nombre de rpi@midominio.net se dirigirá a la bandeja de entrada del usuario "pi". Cualquier otro correo entrante será rechazado.

Ha llegado el momento de arrancar definitivamente postfix. Mapeamos ambos archivo virtuales y reiniciamos el servicio.

$sudo postmap /etc/postfix/virtual

$sudo postmap /etc/postfix/helo_access

$sudo service postfix restart

No deberías ver ningún mensaje de error.

Probando el servicio de envío

Antes de nada saber dónde debemos buscar los mensajes de error y log. Prepárate para lanzar los siguientes comandos 

$cat /var/log/mail.log

$cat /var/log/mail.err

En esos logs encontramos la información de los problemas así como los eventos que suceden en postfix: intentos de conexión, correos enviados y recibidos, etc. Estos archivos rotan frecuentemente y podemos verlos ampliados con mail.log.1, mail.log.2...

Empezamos por lo básico e intentamos enviar directamente un mensaje a nuestra cuenta de gmail. Cada línea se introduce por separado:

$ mail mi-cuenta@gmail.com

Cc: 

Subject: mensaje de prueba de postfix

estas son las líneas de contenido del mensaje para acabarlo y enviar pulsa Ctrl+D

$

El comando acaba sin que aparentemente pase nada pero internamente mail se configura con postfix que inserta el mensaje en su cola de salida e inicia el proceso de comunicación con los servidores de gmail para enviar el mensaje. Poco segundos después deberías ver el mensaje en tu bandeja de entrada aunque es muy probable que haya ido a parar a tu bandeja de spam, si es así ábrelo e indica que no es spam para que acepte futuros mensajes.

Puedes comprobar el proceso de comunicación en el mail.log y las últimas líneas deberían ser algo así.

Feb 17 18:27:21 rpi postfix/pickup[7381]: C64EB42481: uid=1000 from=

Feb 17 18:27:21 rpi postfix/cleanup[7395]: C64EB42481: message-id=<20150217172721 .c64eb42481="" rpi.midominio.net="">

Feb 17 18:27:21 rpi postfix/qmgr[7382]: C64EB42481: from=, size=432, nrcpt=1 (queue active)

Feb 17 18:27:22 rpi postfix/smtp[7397]: C64EB42481: to=, relay=gmail-smtp-in.l.google.com[74.125.140.27]:25, delay=0.89, delays=0.18/0.06/0.42/0.22, dsn=2.0.0, status=sent (250 2.0.0 OK 1424194042 ca16si30265556wib.105 - gsmtp)

Feb 17 18:27:22 rpi postfix/qmgr[7382]: C64EB42481: removed

   

Si el mensaje parece que se ha enviado correctamente pero no llega deberías comprobar el mail.log. A mi me ha llegado a pasar que algún servidor de correo tenía mi IP (dinámica) marcada como generadora de spam. Bastón con acceder al mail.log, comprobar por qué me habían rechazado el correo y acceder a un formulario web para solicitar que la volvieran a habilitar como aceptable.

Probando la recepción de correo

Ahora tocaría recorrer el camino inverso. Hay una dirección de correo que corresponde a un usuario de mi sistema pi@rpi.midominio.net. Desde gmail escribo un mensaje a la misma y uno segundos después acceso por ssh de nuevo a la rpi para comprobar que ha llegado y...

$ ssh pi@rpi.midominio.net

Linux rpi.midominio.net 3.18.7+ #755 PREEMPT Thu Feb 12 17:14:31 GMT 2015 armv6l

[...]

You have new mail.

pi@rpi ~ $

Lo puedes leer usando el mismo comando mail y pulsando 1

$ mail

"/var/mail/pi": 1 mensaje 1 nuevo

>N   1 Gonzalo Cao Cabeza mar feb 17 18:41  44/1923  mensaje de vuelta

? 1

Return-Path:

X-Original-To: pi@rpi.midominio.net

Delivered-To: pi@rpi.midominio.net

Received: from mail-wg0-f51.google.com (mail-wg0-f51.google.com [74.125.82.51])

by rpi.midominio.net (Postfix) with ESMTPS id ABA6342480

for ; Tue, 17 Feb 2015 18:41:02 +0100 (CET)

Received: by mail-wg0-f51.google.com with SMTP id y19so37464344wgg.10

        for ; Tue, 17 Feb 

[...]

Si examinas el mail.log encontraras unas líneas similares a cuando enviaste el correo.

Nos quedan probar las direcciones que hemos virtualizado. Sólo sirven para recibir correo: en el caso de pi@midominio.net la deberíamos recibir en la misma cuenta del caso anterior y para la cuenta webadmin@midominio.net debería recibirla directamente en mi cuenta de correo de gmail.

Asegurando nuestro servidor

Como ya tengo instalado fail2ban lo único que he tenido que hacer es ampliar los jail activados. Edito el /etc/fail2ban/jail.conf y realizo el siguiente cambio

[postfix]

enabled  = true

port     = smtp,ssmtp

filter   = postfix

logpath  = /var/log/mail.log

Con un simple comando podemos observar si fail2ban ha detectado algún comportamiento extraño.

$ sudo fail2ban-client status postfix

Status for the jail: postfix

|- filter

|  |- File list: /var/log/mail.log 

|  |- Currently failed: 0

|  `- Total failed: 0

`- action

   |- Currently banned: 0

   |  `- IP list:

   `- Total banned: 0

Protegiendo el servidor SSH con fail2ban

Configurando fail2ban

Dados los repetidos ataques de fuerza bruta que estoy sufriendo al puerto SSH de mi raspberry pi por parte de ciertas ips desde china he revisado algunos sistemas de protección adicional además de los que ya implementé en su día.

De entre ellos el método más sencillo y que me está resultado más divertido en la instalacion de fail2ban. Este software revisa los logs de diversos servicios autentificados (ssh, apache, smtp...) buscando ataques de fuerza bruta y bloqueando las ips hostiles mediante la introducción de reglas en el iptables. Se pueden seleccionar los servicios que se quieren examinar (fails) y determinar las políticas (o acciones) que se que quieren emprender.

Pero vamos directamente al tema. La instalación básica ya nos servirá:

$sudo apt-get update
$sudo apt-get install fail2ban

Como siempre los ficheros de configuración están en /etc, vamos a darle un vistazo a /etc/fail2ban/jail.conf buscando concretamente estas dos secciones

...
# The DEFAULT allows a global definition of the options. They can be overridden
# in each jail afterwards.

[DEFAULT]

# "ignoreip" can be an IP address, a CIDR mask or a DNS host
ignoreip = 127.0.0.1/8
bantime  = 60000
maxretry = 3

...
[ssh]

enabled  = true
port     = ssh
filter   = sshd
logpath  = /var/log/auth.log
maxretry = 6

En negrita he marcado las partes que más interesan. Puedes ver que he fijado que la acción por defecto es bannear durante 1 hora, que salta al tercer error detectado y lo he activado para el servicio ssh. Salvo el tiempo de baneo todas las demás opciones estaban fijadas por defecto y el servicio ya está en marcha. Si haces cambios en la configuración recuerda reiniciarlo con sudo service fail2ban restart.

Pasado un tiempo podrás ver qué está haciendo examinando el log de fail2ban...

$ cat /var/log/fail2ban.log 

...

2015-02-11 06:52:14,590 fail2ban.server : INFO   Changed logging target to /var/log/fail2ban.log for Fail2ban v0.8.6

2015-02-11 06:52:14,602 fail2ban.jail   : INFO   Creating new jail 'ssh'

2015-02-11 06:52:14,665 fail2ban.jail   : INFO   Jail 'ssh' uses Gamin

2015-02-11 06:52:15,011 fail2ban.filter : INFO   Added logfile = /var/log/auth.log

2015-02-11 06:52:15,022 fail2ban.filter : INFO   Set maxRetry = 6

2015-02-11 06:52:15,038 fail2ban.filter : INFO   Set findtime = 600

2015-02-11 06:52:15,047 fail2ban.actions: INFO   Set banTime = 60000

2015-02-11 06:52:15,800 fail2ban.jail   : INFO   Jail 'ssh' started

2015-02-11 08:11:08,505 fail2ban.actions: WARNING [ssh] Ban 183.136.216.4

2015-02-11 10:05:25,417 fail2ban.actions: WARNING [ssh] Ban 183.136.216.3

2015-02-11 11:58:04,950 fail2ban.actions: WARNING [ssh] Ban 115.239.228.9

... o directamente comunicando con el proceso...

$ sudo fail2ban-client status ssh
Status for the jail: ssh
|- filter
|  |- File list: /var/log/auth.log 
|  |- Currently failed: 1
|  `- Total failed: 22
`- action
   |- Currently banned: 3
   |  `- IP list: 183.136.216.4 183.136.216.3 115.239.228.9 
   `- Total banned: 3

Puedes comprobar cómo ha intoducido las reglas en el iptables con

$ sudo iptables -L
Chain INPUT (policy ACCEPT)
target     prot opt source               destination         
fail2ban-ssh  tcp  --  anywhere             anywhere             multiport dports ssh

Chain FORWARD (policy ACCEPT)
target     prot opt source               destination         

Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination         

Chain fail2ban-ssh (1 references)
target     prot opt source               destination         
DROP       all  --  115.239.228.9        anywhere            
DROP       all  --  183.136.216.3        anywhere            
DROP       all  --  183.136.216.4        anywhere            
RETURN     all  --  anywhere             anywhere   

Yo me he hecho un pequeño script lllamdo f2b_status.sh para de un sólo vistazo comprobar la última actividad del fail2ban

#!/bin/bash
echo
echo "---------------"
echo "Fail2Ban report"
echo "---------------"
echo
echo "Last 20 lines of fail2ban.log"
echo "-----------------------------"
cat /var/log/fail2ban.log | tail -n 20 
echo
echo "fail2ban service status"
echo "-----------------------" 
sudo fail2ban-client status ssh
echo
exit 0

Cómo crear baneos permanentes a ciertas ips

Lo único malo de los baneos es que se acaban (salvo que pongamos bantime  = -1) y es interesante poder introducir reglas que baneen ips definitivamente. Hay una manera muy sencilla: crear un archivo /etc/fail2ban/ip.blacklist y poner una ip por línea (no añadir un retorno de carro al final del archivo o generará un error)

Después abrimos el fichero de la acción por defecto, que si no lo hemos alterado debería ser /etc/fail2ban/action.d/iptables-multiport.conf, y dejar la acción que ejecuta al inicio "actionstart" como sigue:

actionstart = iptables -N fail2ban-
              iptables -A fail2ban- -j RETURN
              iptables -I -p -m multiport --dports -j fail2ban-
              cat /etc/fail2ban/ip.blacklist | while read IP; do iptables -I fail2ban- 1 -s $IP -j DROP; done

Ahora, cada vez que iniciemos el servicio baneará directamente las ips que encuentre el ip.blacklist. Puedes banear rango enteros, algunos ejemplos:

$ cat /etc/fail2ban/ip.blacklist 

183.136.216.4

183.136.216.3

115.239.228.9

115.239.228.0/24

Baneando IPs permanentemente de forma automática

Si como yo te estás hartando de meter manualmente ciertas ips en el blacklist podemos utilizar otra aproximación al problema. Primero: hacer todos los baneos permanentes con bantime=-1,  ten en cuenta que seguirás necesitando usar ip.blacklist para conservar las ips bloqueadas al reiniciar el servicio. Segundo: hacer que  la acción de banear añada directamente la IP al ip.blacklist.

MUCHO OJO:   si no tienes acceso físico al servidor asegúrate de incluyes alguna ip que tengas controlada en ignoreip, podría darse el caso de que un día te equivoques tres veces con la contraseña ¡y no puedas acceder nunca más!

Vamos al lío, comenzamos cambiando /etc/fail2ban/jail.conf

[DEFAULT]

# "ignoreip" can be an IP address, a CIDR mask or a DNS host
ignoreip = 127.0.0.1/8 192.168.0.0/24
bantime  = -1
maxretry = 3

Hemos fijado el bloqueo a permanente y añadido una regla para que ignore los fallos que provengan de la red local. Vamos a cambiar las acciones del /etc/fail2ban/action.d/iptables-multiport.conf, vamos a alterar actionstart y actionban

...

actionstart = iptables -N fail2ban-
              iptables -A fail2ban- -j RETURN
              iptables -I -p -m multiport --dports -j fail2ban-
              cat /etc/fail2ban/ip.blacklist | while read IP; do iptables -I fail2ban- 1 -s $IP -j DROP; done

...

actionban = if ! iptables -C fail2ban- -s -j DROP; then iptables -I fail2ban- 1 -s -j DROP; fi
            # Add offenders to local blacklist, if not already there
            if ! grep -Fxq ',' /etc/fail2ban/ip.blacklist; then echo ',' >> /etc/fail2ban/ip.blacklist; fi

...

Ahora cada vez que banee una ip lo hará de una forma permamente y la incluirá dentro del ip.blacklist. Por el momento si quieres eliminar una IP del blacklist deberás hacerlo manualmente editando el archivo y reiniciando el servicio.

Otra aproximación al problema más avanzada es banear permanentemente sólo aquellas ips que te den problemas de forma reiterada, por ejemplo, aquellas que ya has baneado dos o tres veces. Para eso estás obligado a crear un nuevo jail que, en este caso examine los propios logs del fail2ban buscando las ips hostiles. No estoy seguro de que sea la aproximación más adecuada, introduce más carga de trabajo en el fail2ban y además los hostiles suelen utilizar conjuntos de ips para realizar los ataques con lo cual puedes recibirlos desde varios cientos de IPs. En cualquier caso tienes una buena descripción de la estrategia en este artículo.

Copias de seguridad de tarjetas SD desde linux: guardando nuestra Raspberry Pi

Vista la facilidad con la que se corrompen la tarjetas en mi última instalación completa me he decidido a hacer una copia de seguridad de la RPi para poder restaurarla completamente en unos momentos.

De hecho, como lo utilizo de servidor multimedia y siempre me doy cuenta en el momento de estar sentado frente a la tele, me he creado una copia de respaldo en otra tarjeta para poder cambiarla y en el momento disfrutar de la película.

Usamos una máquina linux y un par de comandos rápidos:

Para hacer la copia de seguridad, me aseguro de meter la tarjeta desmontar las particiones con umount y hacer las copias de seguridad así:

$umount /dev/sdb1
$umount /dev/sdb2
$sudo dd if=/dev/sdb | gzip > /path/a/tu/imagen/nombre.bkp.gz

Y para restaurarla en otra tarjeta o en la misma:

$umount /dev/sdb1
$umount /dev/sdb2

$ sudo gzip -dc /path/a/tu/imagen/nombre.bkp.gz | dd of=/dev/sdb

Puede que tu sistema no monte la tarjeta en /dev/sdb ajústalo a tus necesidades.

Raspberry Pi + Deluge Torrent + MiniDLNA = Happy Sony PS3

El gran partido que le estoy sacando a la Rasberry Pi es en combinación con el servidor de torrent y la PS3. Ahora puedo cargar contenidos desde mi móvil en el servidor de torrent de la RPi y luego consumirlos directamente desde la PS3.

Para ello basta con instalar un servidor multimedia en la RPI que sirva los contenidos. La configuración es muy sencilla.

$ sudo apt-get install minidlna

Edita el archivo de configuración

$sudo nano /etc/minidlna.conf

Busca las siguientes líneas y dale los valores que necesitas

media_dir=/media/usbdisk/torrent #directorio donde debe buscar los archivos

root_container=V   #para que sólo busque archivos de vídeo

friendly_name=RPi  #nombre que verás de la RPi

inotify=yes        #para que revise siempre si aparecen nuevos archivos

Reinicia el servidor para que se lleven a cabo los cambios y escanee las carpetas.

$sudo service minidlna restart
$sudo service minidlna force-reload 

Ya puedes arrancar tu PS3 y buscar tu RPI para disfrutar de tus vídeos.

Instalar torrent en Raspberry Pi - Parte II: Instalar el servidor de torrent (Deluge)

Aunque hay otros servidores de torrent más populares en linux mi preferido sigue siendo Deluge. Es un poco más complicado de configurar pero resulta ser bastante menos voraz con la conexión (sigo pudiendo navegar con mi red) dando una tasas de descarga muy altas. Además permite acceder al servidor desde un sencillo navegador, desde un cliente gráfico en otra máquina o incluso desde un teléfono android usando Transdroid. Esta última opción es especialmente útil porque el propio Transdroid dispone de un buscador así que el método de uso se vuelve especialmente sencillo: arrancamos en nuestro móvil transdroid, buscamos lo que queremos y directamente lo ponemos a descargar en nuestra RPi.

Vamos al método:

Fija la IP
Antes de todo sería conveniente que fijaras la dirección ip de tu RPi, si no será complicado que puedas conectarte a ella desde después. Tienes las instrucciones en este artículo.

Asegurar el espacio en disco
Si no lo has hecho antes es también importante que instales un disco duro externo que permita tener espacio de sobra para tus descargas. En el artículo anterior te explico cómo hacerlo.

En mi caso las descargas se llevarán a cabo en /media/usbdisk/torrent/. Asegúrate que el directorio que escojas exista y sea accesible para tu usuario pi.

Instalar y configurar Deluge server
Las instrucciones están extraídas de la propia web de Deluge y adaptadas a mi caso particular.

Podemos usar el paquete que se distribuye en los repositorios

$sudo apt-get install deluged deluge-console deluge-web

Hacemos una corta ejecución para que genere los archivos de configuración del usuario

$deluged
$pkill deluged

Añadimos un usuario que luego utilizaremos para conectarnos al servidor a través de la red:

$ echo "pi:pipass:10" >> ~/.config/deluge/auth


Ahora viene la configuración del arranque del servidor que es algo más delicada. Tenemos que crear un par de archivos:

$ sudo nano /etc/default/deluge-daemon

y pega este contenido dentro para que sea el usuario pi el que ejecuta deluge

# Configuration for /etc/init.d/deluge-daemon

# The init.d script will only run if this variable non-empty.
DELUGED_USER="pi"    

# Should we run at startup?
RUN_AT_STARTUP="YES"

Ahora creamos el script de arranque, basta con editar el siguiente archivo:

$ sudo nano /etc/init.d/deluge-daemon

Y completarlo con el siguiente contenido:

#!/bin/sh
### BEGIN INIT INFO
# Provides:          deluge-daemon
# Required-Start:    $local_fs $remote_fs
# Required-Stop:     $local_fs $remote_fs
# Should-Start:      $network
# Should-Stop:       $network
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Daemonized version of deluge and webui.
# Description:       Starts the deluge daemon with the user specified in
#                    /etc/default/deluge-daemon.
### END INIT INFO

# Author: Adolfo R. Brandes 

PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
DESC="Deluge Daemon"
NAME1="deluged"
NAME2="deluge"
DAEMON1=/usr/bin/deluged
DAEMON1_ARGS="-d"             # Consult `man deluged` for more options
DAEMON2=/usr/bin/deluge-web
DAEMON2_ARGS=""               # Consult `man deluge-web` for more options
PIDFILE1=/var/run/$NAME1.pid
PIDFILE2=/var/run/$NAME2.pid
UMASK=022                     # Change this to 0 if running deluged as its own user
PKGNAME=deluge-daemon
SCRIPTNAME=/etc/init.d/$PKGNAME

# Exit if the package is not installed
[ -x "$DAEMON1" -a -x "$DAEMON2" ] || exit 0

# Read configuration variable file if it is present
[ -r /etc/default/$PKGNAME ] && . /etc/default/$PKGNAME

# Load the VERBOSE setting and other rcS variables
[ -f /etc/default/rcS ] && . /etc/default/rcS

# Define LSB log_* functions.
# Depend on lsb-base (>= 3.0-6) to ensure that this file is present.
. /lib/lsb/init-functions

if [ -z "$RUN_AT_STARTUP" -o "$RUN_AT_STARTUP" != "YES" ]
then
   log_warning_msg "Not starting $PKGNAME, edit /etc/default/$PKGNAME to start it."
   exit 0
fi

if [ -z "$DELUGED_USER" ]
then
    log_warning_msg "Not starting $PKGNAME, DELUGED_USER not set in /etc/default/$PKGNAME."
    exit 0
fi

#
# Function that starts the daemon/service
#
do_start()
{
   # Return
   #   0 if daemon has been started
   #   1 if daemon was already running
   #   2 if daemon could not be started
   start-stop-daemon --start --background --quiet --pidfile $PIDFILE1 --exec $DAEMON1 \
      --chuid $DELUGED_USER --user $DELUGED_USER --umask $UMASK --test > /dev/null
   RETVAL1="$?"
   start-stop-daemon --start --background --quiet --pidfile $PIDFILE2 --exec $DAEMON2 \
      --chuid $DELUGED_USER --user $DELUGED_USER --umask $UMASK --test > /dev/null
   RETVAL2="$?"
   [ "$RETVAL1" = "0" -a "$RETVAL2" = "0" ] || return 1

   start-stop-daemon --start --background --quiet --pidfile $PIDFILE1 --make-pidfile --exec $DAEMON1 \
      --chuid $DELUGED_USER --user $DELUGED_USER --umask $UMASK -- $DAEMON1_ARGS
   RETVAL1="$?"
        sleep 2
   start-stop-daemon --start --background --quiet --pidfile $PIDFILE2 --make-pidfile --exec $DAEMON2 \
      --chuid $DELUGED_USER --user $DELUGED_USER --umask $UMASK -- $DAEMON2_ARGS
   RETVAL2="$?"
   [ "$RETVAL1" = "0" -a "$RETVAL2" = "0" ] || return 2
}

#
# Function that stops the daemon/service
#
do_stop()
{
   # Return
   #   0 if daemon has been stopped
   #   1 if daemon was already stopped
   #   2 if daemon could not be stopped
   #   other if a failure occurred

   start-stop-daemon --stop --quiet --retry=TERM/30/KILL/5 --user $DELUGED_USER --pidfile $PIDFILE2
   RETVAL2="$?"
   start-stop-daemon --stop --quiet --retry=TERM/30/KILL/5 --user $DELUGED_USER --pidfile $PIDFILE1
   RETVAL1="$?"
   [ "$RETVAL1" = "2" -o "$RETVAL2" = "2" ] && return 2

   rm -f $PIDFILE1 $PIDFILE2

   [ "$RETVAL1" = "0" -a "$RETVAL2" = "0" ] && return 0 || return 1
}

case "$1" in
  start)
   [ "$VERBOSE" != no ] && log_daemon_msg "Starting $DESC" "$NAME1"
   do_start
   case "$?" in
      0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
      2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
   esac
   ;;
  stop)
   [ "$VERBOSE" != no ] && log_daemon_msg "Stopping $DESC" "$NAME1"
   do_stop
   case "$?" in
      0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
      2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
   esac
   ;;
  restart|force-reload)
   log_daemon_msg "Restarting $DESC" "$NAME1"
   do_stop
   case "$?" in
     0|1)
      do_start
      case "$?" in
         0) log_end_msg 0 ;;
         1) log_end_msg 1 ;; # Old process is still running
         *) log_end_msg 1 ;; # Failed to start
      esac
      ;;
     *)
        # Failed to stop
      log_end_msg 1
      ;;
   esac
   ;;
  *)
   echo "Usage: $SCRIPTNAME {start|stop|restart|force-reload}" >&2
   exit 3
   ;;
esac

:

Convertimos el archivo en ejecutable...

$sudo chmod 755 /etc/init.d/deluge-daemon

...con el siguiente comando hacemos que se ejecute en cada arranque...

$sudo update-rc.d deluge-daemon defaults

Y ya podemos arrancar el servidor...

$sudo service deluge-daemon start

Ya deberías poder conectar con el servidor abriendo tu navegador y visitando la dirección http://192.168.0.254:8112/ (ajustando la IP a la de tu RPi). Es el momento adecuado para que configures la carpeta donde quieres que realicen las descargas y demás.

Configurando Deluge para acceder con otros clientes

Habilitamos el acceso remoto para poder acceder desde nuestro nuestro portatil con el GUI

$deluge-console "config -s allow_remote True"

$deluge-console "config allow_remote"

$sudo service deluge-daemon restart

Ya puedes configurar tu cliente de Deluge en tu portátil.

Para configurar Transdroid debes asegurarte que el servidor web se conecta automáticamente al servidor local de Deluge. Lo apagamos, editamos la configuración y lo volvemos a arrancar.

$sudo service deluge-daemon restart

$nano ~/.config/deluge/web.conf

Busca la siguiente línea y la cambias así

"default_daemon": "" 

"default_daemon": "127.0.0.1:58845"

Protege de cambios el archivo web.conf para que no se actualice en cada arranque:

$chmod 444 ~/.config/deluge/web.conf

Ya puedes reiniciar el servidor y conectar con Transdroid.

$sudo service deluge-daemon start

Instalar torrent en Raspberry Pi - Parte I: Configurar un disco duro por usb

Uno de los aspectos más interesantes de la RPI es su bajo consumo y su capacidad para realizar tareas que no necesitan demasiado capacidad de cálculo. En este caso pretendo evitar tener que dejar el pc de escritorio encendido para una tarea tan sencilla como descargar torrents. Como una tarjeta SD no proporciona mucho espacio, lo conveniente es añadir un disco externo por USB. Así pues divido el tutorial en dos partes: la configuración de un disco duro y la instalación del servicio de torrent.

Montar un disco duro fijo

Ante todo dejar claro que yo utilizo la RPI únicamente por línea de comandos y ssh a través de la red, no tengo monitor enganchado. Asegúrate de que sabes conectar con tu terminal antes de empezar. También parto de que tienes un disco duro listo y formateado, en mi caso lo tengo formateado en ext4 para poder aprovecharme de todas las ventajas de ese sistema. También serviría un disco fat e incluso ntfs aunque la configuración variaría ligeramente. Consulta este enlace si tienes dudas respecto a que opciones debes poner más adelante en el fstab.

Lo primero que vamos a crear es un punto de montaje, es decir, el directorio en el que estará disponible el nuevo disco duro. Por convención se suelen usar los directorio /mnt/nombre_disco o /media/nombre_disco. Lo hacemos con en siguiente comando:

$sudo mkdir /media/usbdisk

$sudo chmod 777 /media/usbdisk

Es importante el segundo comando para asegurarnos que una vez montados el disco cualquier usuario podrá añadir o borrar carpetas o archivos en él. Puede parecer una brecha de seguridad (y de hecho no es nada recomendable en un sistema serio) pero es la forma más sencilla de que tanto el usuario pi (el que usamos normalmente) como el del servicio torrent puedan acceder a los archivos sin problemas. Aprende algo más sobre el sistema de permisos unix si tienes curiosidad.

Para terminar vamos a crear un enlace sencillo que nos permitirá acceder desde nuestro directorio de usuario al disco duro de una forma más directa. Este paso es opcional pero ¡así aprendes a hacer un enlace!

$ln -s /media/usbdisk/ /home/pi/usbdisk

Vale, ya tenemos el punto de enlace listo. Ahora toca montar el disco duro. Encendemos la alimentación si es necesario y conectamos el disco por usb. Después de un ejecuta:

$sudo blkid

Debería aparecerte algo así:

/dev/mmcblk0p1: SEC_TYPE="msdos" UUID="3312-932F" TYPE="vfat" 
/dev/mmcblk0p2: UUID="b7b5ddff-ddb4-48dd-84d2-dd47bf00564a" TYPE="ext4" 
/dev/sda1: UUID="497daa7e-50f7-4d8b-8013-6c02ad83056d" TYPE="ext4" 

Lo que aparece como /dev/sda o /dev/sdb son los dispositivos de disco duro, lo que aparece como /dev/sda1 /dev/sda2 o /dev/sdb1... son las particiones que tiene tu disco (todo en linux es un archivo). En mi caso sólo hay un disco (/dev/sda) con una única partición (/dev/sda1). Pues bien ahora lo que vamos a hacer es montar esa partición con el comando mount.

$sudo mount /dev/sda1 /media/usbdisk

Asegurate de poner el /dev/sdxx correpondiente a lo que hayas obtenido en el paso anterior... y si no ves ningún mensaje de error ¡ya está! ¡disco montado! puedes ir a la carpeta y comprobar que funciona, creando unos archivos y carpetas. También puedes usar este comando para obtener un poco más de información:

$ df -T

Filesystem     Type     1K-blocks     Used Available Use% Mounted on

rootfs         rootfs     7591392  1603680   5602248  23% /

/dev/root      ext4       7591392  1603680   5602248  23% /

devtmpfs       devtmpfs    224436        0    224436   0% /dev

tmpfs          tmpfs        44900      224     44676   1% /run

tmpfs          tmpfs         5120        0      5120   0% /run/lock

tmpfs          tmpfs        89780        0     89780   0% /run/shm

/dev/mmcblk0p1 vfat         57288    16872     40416  30% /boot

/dev/sda1      ext4     115379200 11968804 103410396  11% /media/usbdisk

En la última línea puedes ver mi partición /dev/sda1 en formato ext4 montada en /media/usbdisk y con sólo el 11% de su capacidad usada.

Montarlo automáticamente al arrancar

Evidente no vamos a estar pendientes cada vez que arranquemos la RPI de montar manualmente el disco duro. Para que lo cargue automáticamente en el inicio debemos incluir en el fstab ¿Cómo? muy sencillo. Primero asegúrate de desmontar el disco duro:

$sudo umount /dev/sda1

Editamos el archivo fstab:

$sudo nano /etc/fstab

...y le añadimos la siguiente línea al final:

/dev/sda1  /media/usbdisk  ext4  defaults  0  0

Teniendo en cuenta que el sda debe ser el tuyo. Donde pone ext4 es por mi sistema de archivos, si el tuyo es fat deberíamos poner vfat y si es ntfs, pues eso, ntfs. Consulta el enlace de arriba si tienes dudas.

Si lo hemos hecho todo bien ahora podemos referirnos directamente a la carpeta de destino para montar el sistema:

$sudo mount /media/usbdisk

¡Otro paso dado! Ahora cada vez que arranque y el disco duro esté pinchado lo montará automáticamente en esa localización. 

Ya casi lo podríamos dejar así pero le vamos a dar una vuelta de tuerca más. Tal vez ya se te haya ocurrido ¿qué pasa si pongo varios discos duros?¿o si lo cambio de puerto USB? ¿cómo sabe qué disco tiene que montar en cada punto?

Pues la respuesta corta es "no lo sabe". Al menos de momento. Tenemos que especificarle que no nos sirve cualquier disco duro si no que es uno en concreto el que queremos montar en /media/usbdisk. Lo primero será indentificar la partición con un código que se genera al crearla. Para obtener el UUID podemos usar el mismo comando de antes:

/dev/mmcblk0p1: SEC_TYPE="msdos" UUID="3312-932F" TYPE="vfat" 
/dev/mmcblk0p2: UUID="b7b5ddff-ddb4-48dd-84d2-dd47bf00564a" TYPE="ext4" 
/dev/sda1: UUID="497daa7e-50f7-4d8b-8013-6c02ad83056d" TYPE="ext4" 

En negrita puedes ver la UUID de mi disco, en tu caso puede ser igual o más corta lo importante es identificar la partición con el sdxx correpondiente. Ahora copiamos esa cadena y la sustituimos en la línea del fstab:

UUID=497daa7e-50f7-4d8b-8013-6c02ad83056d /media/usbdisk  ext4  defaults  0  0

...y lo probamos con mount y umount. Si no nos da problemas ¡ya está todo! Tenemos un disco identificado unívocamente que se montará en cada arranque en una carpeta en concreto. Todo está listo para instalar nuestro cliente de Torrent.

Instalar gphoto2 2.5 en raspberry pi

EDITO:
Como esto es bastante más largo de lo que pensaba antes de empezar la entrada he creado un pequeño script que realiza todos los pasos automáticamente. Está disponible en https://github.com/gonzalo/gphoto2-updater 

Una de mis proyectos con RPI tiene que ver con la cámara DSLR Olympus E-520 que tengo. Para poder controlarla desde el ordenador podemos usar el software gphoto2. Lamentablemente la versión disponible en debian y, por extensión, en Raspbian es algo antigua la 2.4.14. Así que para poder ponerme al día he tenido que compilar e instalar la nueva versión.

Te recomiendo desinstalar gphoto2 si lo has hecho para evitar confusiones.

sudo apt-get remove gphoto2

Para empezar he bajado el código fuente desde la página del proyecto y descomprimido.

wget http://downloads.sourceforge.net/project/gphoto/libgphoto/2.5.0/libgphoto2-2.5.0.tar.bz2?r=&ts=1358269367&use_mirror=freefr

(tendras que renombrar el archivo porque wget le pondrá un nombre muy largo)

tar xjf libgphoto2-2.5.0.tar.bz2
cd libgphoto2-2.5.0

A partir de ahí los clásicos comandos para configurar y compilar el proyecto

./configure

checking for a BSD-compatible install... /usr/bin/install -c
checking whether build environment is sane... yes
checking for a thread-safe mkdir -p... /bin/mkdir -p
checking for gawk... no
checking for mawk... mawk
checking whether make sets $(MAKE)... yes
checking for POSIX sh $() command substitution... yes
checking for gcc... gcc

(...y mucho código más...)

Ojo a la salida de este comando que nos avisa de qué nos falta. A mi me dio un aviso de falta de las librerías libltdl y libusb. Nada que no se pueda arreglar con apt-get

$ sudo apt-get install libltdl-dev
$ sudo apt-get install libusb-dev

Lanzo de nuevo configure y compruebo los resultados...y sigue sin poder compilar. Resulta que la versión de libusb no es lo bastante reciente para él. Toca bajar del código fuente de libusb1.0, compilarlo e instalarlo (esto se empieza a parecer a las cosas que no me gustan de linux :-D)

wget http://ftp.de.debian.org/debian/pool/main/libu/libusbx/libusbx_1.0.11.orig.tar.bz2
tar xjvf libusbx_1.0.11.orig.tar.bz2
cd libusbx-1.0.11/
./configure
make
sudo make install

Ya tengo instalada la nueva libusb. Lanzo de nuevo configure y parece que todo es correcto.

./configure
make 
(zzz...zzzz....zzzz....zzzz...zzzz...zzzz....)
sudo make install

...y después de un buen rato ¡por fin! Por fin tienes instaladas las librerías, ahora toca compilar e instalar gphoto2. Antes instalamos las dependencias exigidas.

sudo apt-get install libexif-dev
sudo apt-get install libpopt-dev

Descargamos, compilamos e instalamos gphot2

wget http://downloads.sourceforge.net/project/gphoto/gphoto/2.5.0/gphoto2-2.5.0.tar.gz?r=http%3A%2F%2Fsourceforge.net%2Fprojects%2Fgphoto%2Ffiles%2Fgphoto%2F2.5.0%2F&ts=1358271589&use_mirror=freefr

(tendras que renombrar el archivo porque wget le pondrá un nombre muy largo)

tarx zvf gphoto2-2.5.0.tar.gz

cd gphoto2-2.5.0

./configure

make

sudo make install

Y ya tengo instalado por fin gphoto2 versión 2.5. Queda un detallito tienes que ejecutar el siguiente comando para que enlace correctamente las librerías:

sudo ldconfig

Y ahora sí que sí. Gphoto2 y librerías correspondientes correctamente instaladas

$ gphoto2 --version
gphoto2 2.5.0

Copyright (c) 2000-2012 Lutz Mueller and others

gphoto2 comes with NO WARRANTY, to the extent permitted by law. You may
redistribute copies of gphoto2 under the terms of the GNU General Public
License. For more information about these matters, see the files named COPYING.

This version of gphoto2 is using the following software versions and options:
gphoto2         2.5.0          gcc, popt(m), exif, no cdk, no aa, no jpeg, no readline
libgphoto2      2.5.0          all camlibs, gcc, ltdl, no EXIF
libgphoto2_port 0.10.0         gcc, ltdl, USB, serial without locking

Protegiendo un poco nuestra Raspberry Pi de ataques externos (ssh)

La historia de siempre, basta con conectar un aparato a internet para que un montón de bots empiecen a atacarlo a ver si consiguen acceder. A raíz de este post se me ocurrió investigar el fichero de log del sshd a ver si tenía algún intento de acceso ilegal. Pues en menos de 12 horas tenía ¡1728 intentos de acceso! La mayoría a la cuenta root.

Este es el comando que muestra por pantalla:
cat /var/log/auth.log | grep 'invalid user\|Failed'

...y este el que cuenta cuántos líneas aparecen:
cat /var/log/auth.log | grep 'invalid user\|Failed' | wc -l

Hay varias cosas que podemos hacer para evitar cualquier problema.

Contraseña
Es obvio pero la primera es asegurarnos de que cambiamos la contraseña por defecto y que no lo hacemos por otra que sea obvia como "12345", "password" y cosas así. Lo puedes hacer directamente desde el menú de raspi-config (sudo raspi-config) o con el comando passwd

Desactivar el login con root desde ssh
Edita el fichero de configuración de ssh

sudo nano /etc/ssh/sshd_config

Cambia "PermitRootLogin yes" por

PermitRootLogin no

Bloqueos ataques fuerza bruta
Añade estas línea al final del sshd_config para bloquear el número máximo de accesos fallidos desde una IP y el número máximo de sesiones simultáneas que se pueden abrir.


# Custom settings
MaxAuthTries 3
MaxStartups 5

Frikonsejo: Puedes comprobar que tu configuración del sshd es correcta mediante el comando

$ sudo sshd -t

Si no ves ningún mensaje de error es que la configuración es correcta. Es muy importante que compruebes que el archivo de configuración es correcto porque si no cuando reinicies el servicio (o la máquina) el servicio ssh no arrancará y no podrás conectarte

Cambio de puerto estándar
No es una medida definitiva pero te evitará muchos ataques automáticos de los bots que circulan por Internet. Basta con que cambies el puerto que has abierto en el router a cualquier otro no estándar. En la redirección indicas que sigues queriendo enviarlo al 22 de tu IP en la red interna. Pero ten cuidado porque muchos proveedores de internet no permiten conectarse al rango completo de puertos de tu router. Comprueba con una herramienta como http://www.yougetsignal.com/tools/open-ports/ si el puerto realmente está abierto y accesible.

Bloqueo de IP, límites de anchos de banda...
Hay muchas más estrategias que puedes aplicar para proteger tus puertos pero en ocasiones son algo rígidas y más orientadas a sistemas multiusuario.

Aquí tienes una buena colección de estrategias para proteger tu servidor ssh

ACTUALIZACIÓN: en vista de la cantidad de ataques por fuerza bruta que sufro en mi puerto 22 he instalado un servicio de baneo de IPs. Aquí lo explico con más detalle.

Configurar wifi usb en Raspberry Pi

Es muy fácil y económico añadir conectividad wifi a tu RPI. Hace poco pedí a Dealextreme este dispositivo wifi por USB pequeño y muy barato (por poco más de 6€ en casa).

Hace un rato me ha llegado y en un momento ya lo tengo funcionando. Bastaba con conectarlo para que lo reconociera así que sólo hace falta configurar los datos de nuestra wifi para tenerlo en marcha. Primero comprobamos que el sistema ha reconocido el dispositivo correctamente.


 $ ifconfig
eth0      Link encap:Ethernet  HWaddr b8:27:eb:40:af:2c  
          inet addr:192.168.0.254  Bcast:192.168.0.255  Mask:255.255.255.0
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:121 errors:0 dropped:1 overruns:0 frame:0
          TX packets:105 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:15687 (15.3 KiB)  TX bytes:13555 (13.2 KiB)

lo        Link encap:Local Loopback  
          inet addr:127.0.0.1  Mask:255.0.0.0
          UP LOOPBACK RUNNING  MTU:16436  Metric:1
          RX packets:55 errors:0 dropped:0 overruns:0 frame:0
          TX packets:55 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0 
          RX bytes:9890 (9.6 KiB)  TX bytes:9890 (9.6 KiB)

wlan0     Link encap:Ethernet  HWaddr e8:4e:06:0c:d4:27  
          UP BROADCAST MULTICAST  MTU:1500  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)

Sabiendo que el sistema ha reconocido correctamente el dongle vamos a configurar la wifi. Primero generamos la passphrase de nuestra wifi. Se hace con un simple comando:

$ wpa_passphrase SSID_DE_TU_RED PASSWORD

network={

ssid="SSID_DE_TU_RED"

#psk="PASSWORD"

psk=64958acd6XXXXXXXXXX9eecbac86243a19960224ace0d8e148c329ec

}

Copiamos en el portapapeles el valor del psk y lo guardamos para usarlo más adelante. A continuación editamos el archivo de configuración de los interfaces de red.

$ sudo joe /etc/network/interfaces

...y lo editamos de la siguiente forma:

allow-hotplug wlan0

#iface wlan0 inet manual

#wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf

iface wlan0 inet dhcp

wpa-ssid "SSID_DE_TU_RED"

wpa-psk 64958acd6XXXXXXXXXX9eecbac86243a19960224ace0d8e148c329ec

iface default inet dhcp

(Deja las líneas del eth0 tal y como están)

...y ya está sólo hace falta reiniciar la RPI para que tengamos la wlan activa.

$ sudo reboot

Al reiniciar ya podemos ver activo nuestro dispositivo con su flamante IP

$ ifconfig

eth0      Link encap:Ethernet  HWaddr b8:27:eb:40:af:2c  

          inet addr:192.168.0.254  Bcast:192.168.0.255  Mask:255.255.255.0

          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1

          RX packets:120 errors:0 dropped:2 overruns:0 frame:0

          TX packets:102 errors:0 dropped:0 overruns:0 carrier:0

          collisions:0 txqueuelen:1000 

          RX bytes:14730 (14.3 KiB)  TX bytes:13592 (13.2 KiB)

lo        Link encap:Local Loopback  

          inet addr:127.0.0.1  Mask:255.0.0.0

          UP LOOPBACK RUNNING  MTU:16436  Metric:1

          RX packets:55 errors:0 dropped:0 overruns:0 frame:0

          TX packets:55 errors:0 dropped:0 overruns:0 carrier:0

          collisions:0 txqueuelen:0 

          RX bytes:9876 (9.6 KiB)  TX bytes:9876 (9.6 KiB)

wlan0     Link encap:Ethernet  HWaddr e8:4e:06:0c:d4:27  

          inet addr:192.168.0.9  Bcast:192.168.0.255  Mask:255.255.255.0

          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1

          RX packets:26 errors:0 dropped:37 overruns:0 frame:0

          TX packets:18 errors:0 dropped:0 overruns:0 carrier:0

          collisions:0 txqueuelen:1000 

          RX bytes:5608 (5.4 KiB)  TX bytes:4573 (4.4 KiB)

Fijar la IP

Es posible que quieras que la IP asignada sea fija para poder acceder a ella sin problemas. Edita de nuevo el fichero /etc/network/interfaces y sustituye los contenidos por los siguientes


auto lo

iface lo inet loopback
iface eth0 inet dhcp

allow-hotplug wlan0
#iface wlan0 inet dhcp
#wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
iface wlan0 inet static
        address 192.168.0.254
        netmask 255.255.255.0
        network 192.168.0.0
        gateway 192.168.0.1
        wpa-ssid "SSID_DE_TU_RED"
        wpa-psk 64958acd6XXXXeecbac86243a19960224ace0d8e148c329ec
iface default inet dhcp

No olvides ajustar los detalles de IP, SSID y PSK a los de tu red.