INSTALACIÓN DE UFW EN RASPBERRY PI 2

Siempre es importante tener un cortafuegos adecuado en nuestra Raspberry para evitar posibles ataques e intrusiones desde el exterior o desde nuestra propia LAN.
Sabemos que utilizando el comando "iptables" el trabajo de configurar un cortafuegos puede ser largo y tedioso, por eso hoy veremos y utilizaremos el programa "UFW" (uncomplicated firewall).

Este programa, como su propio nombre indica, nos ayudará a configurar nuestro cortafuegos de forma relativamente sencilla a través de "iptables". 

Instalaremos el paquete  de la manera habitual:

$ sudo apt-get install ufw

Cuando se instala "UFW" por primera vez,  el firewall se configura por defecto para que las conexiones entrantes se bloqueen y se permitan las salientes, esto equivaldría a:

$ sudo ufw default deny incoming 
$ sudo ufw default allow outgoing

Antes de añadir ninguna regla, es importante asegurarse de comprobar el estado y las reglas por defecto que tenemos en el firewall con el comando:

$ sudo ufw status verbose

Vemos cómo el servicio está activo, y tiene como política denegar las conexiones entrantes y habilitar las salientes.

Si queremos ver mas detalles o editar la configuración por defecto de "UFW" podemos modificar su fichero ubicado en  /etc/default/ufw.

Una de las formas para averiguar que puertos deberíamos abrir, es localizar los que están en modo escucha con el comando "nstat":

$ sudo netstat -tanp | grep LISTEN

Para añadir reglas que permitan que cualquier ip pueda conectarse por un puerto añadimos:

$ sudo allow 8070

Si queremos que permita sólo conexiones con protocolo TCP:

$ sudo allow 8070/tcp

Abrir un rango de puertos:

$ sudo allow 8070:8090/tcp

Admitir la conexión de un puerto desde una red o una ip concreta:

$ sudo ufw allow from 192.168.0.0/24 to any port 5151

$ sudo ufw allow from 192.168.0.1 to 127.0.0.1 port 5151

"UFW" también permite abrir puertos por el nombre de la aplicación. Para saber la lista de aplicaciones que vienen predefinidas ejecutamos:

$ sudo ufw app list

Por lo que abrir un puerto mediante el nombre de la aplicación es tan fácil como:

$ sudo ufw allow SMTP

Podemos editar esta lista de aplicaciones en el archivo /etc/ufw/applications.d.

Si lo que deseamos es denegar  alguna conexión, seguimos el mismo procedimiento que usábamos para hablitar puertos, pero con la opción "deny":

$ sudo deny 8989/udp

Para borrar alguna regla introducida:

$sudo delete deny 8989/udp

Podemos igualmente activar o desactivar nuestro firewall de manera sencilla:

$ sudo ufw enable
$ sudo ufw disable

Y para borrar todas las reglas sólo hace falta ejecutar el siguiente comando:

$ sudo ufw reset

En "UFW" podemos activar o desactivar los "logs" para comprobar conexiones, errores,..  del firewall:

$ sudo ufw logging on 
$ sudo ufw logging off

Existen tres tipos de niveles de "logs": "low", "medium" y "high". Por defecto este estado está en "low". Para cambiarlo simplemente editamos el archivo /etc/ufw/ufw.conf:

En este archivo también encontramos la línea "ENABLE=yes". Esta nos sirve para que cuando inicie la Raspberry se active automáticamente el firewall.

Con toda esta información ya podemos configurar nuestro firewall acorde a nuestras necesidades. En próximos tutoriales veremos cómo profundizar un poco más en las configuraciones de "UFW" cuando veamos la instalación de "Openvpn" en la Raspberry PI 2.
Hasta otra...

INSTALACIÓN SERVIDOR DHCP EN RASPBERRY PI 2

""DHCP (siglas en inglés de Dynamic Host Configuration Protocol, en español «protocolo de configuración dinámica de host») es un protocolo de red que permite a los clientes de una red IP obtener sus parámetros de configuración automáticamente. Se trata de un protocolo de tipo cliente/servidor en el que generalmente un servidor posee una lista de direcciones IP dinámicas y las va asignando a los clientes conforme éstas van quedando libres, sabiendo en todo momento quién ha estado en posesión de esa IP, cuánto tiempo la ha tenido y a quién se la ha asignado después.".

Uno de los servicios más sencillos que podemos implementar en nuestra Raspberry Pi 2 es un servidor DHCP, el cual permitirá otorgar una configuración de red automática para que los clientes puedan acceder a nuestra red y a sus recursos. 
Esta función normalmente la hace nuestro router doméstico, pero tendremos un mayor control (de concesiones por ejemplo) si la implementamos en la Raspberry.

El primer paso será instalar el paquete isc-dhcp-server:

$ sudo apt-get install isc-dhcp-server

Al final de la instalación, el servidor nos devolverá un error al reiniciar el servicio ya que todavía no tenemos una configuración adecuada.

Antes de nada, lo que debemos definir es la "interface de red" que va a utilizar la Raspberry para escuchar las peticiones DHCP de los clientes, que en nuestro caso será el dispositivo Ethernet (eth0) que viene de fábrica en la placa. 
Si no tenemos muy claro cuál es la "interface" que vamos a utilizar, con el comando "ifconfig" podemos detectarla rápidamente.

Identificado nuestro dispositivo de red, pasaremos a configurar la "interface" que escuchará las peticiones en el archivo /etc/default/isc-dhcp-server:

$ sudo /etc/default/isc-dhcp-server

Modificaremos lo siguiente :

INTERFACES=“eth0”

Configuraremos ahora los parámetros generales del servidor. Abrimos el archivo /etc/dhcp/dhcpd.conf.

Aunque este archivo es denso, casi todo el contenido está comentado. Si queremos podemos borrar todas las líneas comentadas y dejar solo lo necesario para su configuración.

Debemos tener en cuenta que hay dos tipos de opciones:

• Opciones globales del servidor DHCP: son las configuraciones propias del servidor ( tiempo máximo de concesión,..).
• Opciones generales de la subred: Son las opciones que ofrece el servidor a sus clientes (puerta de enlace, servidores DNS,...).

Añadiremos los siguientes parámetros, teniendo en cuenta, entre otras cosas, cual es nuestra subred y la puerta de enlace para comunicarnos con el exterior:

#Opciones globales del servidor ddns-update-style none; # Sirve para actualizar los registros DNS. option domain-name "home.local"; # Si queremos elegir un nombre de dominio. option domain-name-servers 8.8.8.8, 8.8.4.4; # Son las ips de los servidores DNS. default-lease-time 259200; #Tiempo por defecto de la concesión en segundos. max-lease-time 604800; #Tiempo máximo de la concesión en segundos. authoritative; #Establece el servidor como principal. log-facility local7; #Opciones de subred subnet 192.168.0.0 netmask 255.255.255.0 { #Declaración de la subred. range 192.168.0.100 192.168.66.199; # Rango de direcciones que el sevidor va a otorgar. option routers 192.168.0.100; #Gateway (nuestro router). option subnet-mask 255.255.255.0; #Máscara de nuestra subred. option broadcast-address 192.168.0.255; #Dirección de broadcast de la LAN. } #Reserva de direcciones por si queremos otorgar siempre la misma ip a un cliente. host pc1 { #Declaramos la reserva hardware ethernet 00:11:22:33:44:55; #Dirección MAC del dispositivo. fixed-address 192.168.0.110; #Dirección IP reservada. }

Ya tenemos todos los elementos necesarios para implementar nuestro servidor DHCP. Reiniciamos el servicio:

$ sudo /etc/init.d/isc-dhcp-server restart


Ahora nos conectamos por ejemplo a un pc Windows para verificar el correcto funcionamiento del servidor. Teniendo la tarjeta de red del pc en DHCP verificamos que nuestro servidor  nos va a  conceder una configuración automática de red. Lo verificamos con el comando "ipconfig" en el CMD:

$ ipconfig /release
$ ipconfig /renew

A los pocos segundos nuestro pc aceptará la configuración que nos ha ofrecido el servidor. Lo podremos comprobar con el comando "ipconfig /all", que nos devolverá:

Si por el contrario nos conectamos a un cliente linux podemos pedir una configuración de red al servidor DHCP  a través del comando "dhclient":

Por tanto, ya tenemos impementado el servicio DHCP en nuestra Raspberry PI 2 y funcionando a la perfección.

Si queremos ver la lista de las concesiones ofrecidas a los clientes conectados abrimos el archivo /var/lib/dhcp/dhcpd.leases :

$ sudo cat /var/lib/dhcp/dhcpd.leases

INSTALACIÓN DE VSFTP EN RASPBERRY Pt.2

En el anterior tutorial vimos como configurar un servidor "vsftpd" en Raspbian. Hoy veremos cómo evitar ataques de fuerza bruta y también cómo crear certificados SSL para encriptar las conexiones entre cliente y servidor, obteniendo así un poco más de seguridad.

Para generar nuestro certificado propio SSL, es imprescindible utilizar el programa "OpenSSL" (por defecto  está instalado en Raspbian):

$ sudo apt-get install openssl

Una vez instalado, procedemos a la creación del certificado:

$  sudo openssl req -x509 -nodes -days 365 -newkey rsa:1024 -keyout /etc/ssl/private/vsftpd.pem -out /etc/ssl/private/vsftpd.pem

Vemos las opciones:

-days: es la caducidad  del certificado.
-newkey rsa:1204: es el tipo y los bytes de encriptación (RSA 1024 bit).
-out: el directorio donde se almacenara el archivo del certificado.

A continuación accederemos al archivo de configuración del servidor ftp:

$ sudo nano /etc/vsftpv.conf

Insertamos los siguientes parámetros:

ssl_enable=YES allow_anon_ssl=NO force_local_data_ssl=NO force_local_logins_ssl=NO ssl_tlsv1=YES ssl_sslv2=NO ssl_sslv3=NO require_ssl_reuse=NO ssl_ciphers=HIGH rsa_cert_file=/etc/ssl/private/vsftpd.pem

También es importante reforzar  un poco más nuestro servidor FTP, por ello añadiremos las siguientes líneas en el archivo de configuración:

rsa_cert_file=/etc/ssl/private/vsftpd.pem max_clients=2 #Máximo de clientes que se conectarán simultáneamente. max_per_ip=2 #Límite de ips que se conectarán simultáneamente. max_login_fails=1 #Máximo de login fallidos. delay_failed_login=30 #Tiempo de espera tras el último login fallido.

Reiniciamos el servicio:

$ sudo /etc/init.d/vsftpd restart

Ya tenemos un mínimo de seguridad para conectarnos vía ftp desde el exterior (ip pública). Es importante abrir los puertos en el router, tanto para la conexión (21 por defecto si no la hemos cambiado) como para el modo pasivo (abrir los rangos que estén en el archivo de configuración /etc/vsftpd.conf>pasv_min_port-pasv_max_port).

Configurado todo, nos conectaremos al servidor  mediante algún cliente ftp (Filezilla) desde fuera de nuestra LAN, elegimos el  modo ftp explícito sobre TLS y nos aparecerá un certificado como el siguiente:

Una vez aceptada la conexión entre cliente/servidor estará cifrada.

INSTALACIÓN DE VSFTP EN RASPBERRY Pt.1

FTP es un protocolo de transmisión de archivos entre cliente y servidor muy común para el intercambio de ficheros, como por ejemplo, para un servidor web.
Hoy explicaremos cómo instalar el programa "vsftpd" que servirá como servicio en La Raspberry PI 2.

Para instalar la aplicación abrimos nuestro terminal y escribimos:

$ sudo apt-get install vsftpd

Una vez instalado, vamos al archivo de configuración para modificar ciertos parámetros:

$ sudo nano /etc/vsftpd.conf

Nos detendremos en  los  más importantes a la hora de configurarlo:

listen = YES                        #Para que se inicie el servicio con el sistema. listen_port=8080                 #Puerto de escucha. Recomendable cambiarlo por razones de                                                        #seguridad. pasv_enable=YES               #Conexión en modo pasivo (más seguro). pasv_promiscuous=YES     # Modo promíscuo pasv_min_port=3000           # Rango mínimo de los puertos en modo pasivo. pasv_max_port=3099          # Rango máximo de los puertos en modo pasivo. anonymous_enable = NO    #No permitimos que usuarios anónimos puedan conectarse a                                                          #nuestro servidor.  local_enable = YES              #Para poder conectarse con los usuarios locales del servidor                                                            #donde está instalado. write_enable = YES              #Si quieres que los usuarios puedan escribir y no sólo                                                                      #descargar. local_umask = 022                #Esta máscara hace que cada vez que subas un archivo, sus                                                           #permisos sean 755 (recomendable). userlist_enable=YES            #Lista de usuarios que se podrán conectar por ftp. userlist_deny=NO                 #Lista de usuarios a los que se les prohibirá el acceso.  userlist_file=/etc/user_list    #Archivo y ruta que contiene los usuarios permitidos. Hay                                                                 #que crearlo, y se rellenara con los nombres de los usuarios                                                             #en cada fila. vsftpd_log_file=/var/log/vsftpd.log       #Archivo que contendrá los logs del servicio FTP. chroot_local_user = YES        # Para enjaular a los usuarios en un directorio específico. chroot_list_enable = YES       #Sirven para que los usuarios locales puedan navegar por                                                               #todo el árbol de directorios del servidor. chroot_list_file = /etc/vsftpd.chroot_list    # Lista de usuarios que podrán acceder al                                                                     #árbol de directorios.

Indicamos el fichero donde están listados los usuarios que pueden navegar hacía arriba por los directorios del servidor, lo normal es que sea el administrador del servidor y poco más.
El fichero “vsftpd.chroot_list” y “user_list” no suele existir así que debemos crearlo y editarlo. 

En “user_list” incluimos a los usuarios que queremos que puedan contectarse al servidor:

$ sudo nano /etc/user_list

En “vsftpd.chroot_list” asignameros los nombres de usuarios que queremos que puedan listar todos los directorios del servidor y no sólo el suyo asignado por FTP (administradores,..):

$ sudo nano /etc/vsftpd.chroot_list

Basta con escribir solo el nombre del usuario en cada fila. 
Para que jerarquizar todo perfectamente, crearemos un grupo y unos usuarios exclusivamente para conectarse vía ftp.

Creamos primero el grupo:

$ sudo groupadd ftpusers.

Después creamos un usuario ftp in que tenga derecho a un shell:

$ sudo useradd -g ftpusers -s /bin/false -d /home/ftp/usuario usuario

Las opciones son:

-g ftpusers: el usuario pertenece al grupo ftpusers.
-d /home/ftp/usuario: el directorio principal del usuario es /home/ftp/usuario. 
-s /bin/false: el Shell fantasma que no va a poder utilizar el usuario.

Asignamos una contraseña al nuevo usuario:

$ sudo passwd usuario

Hay que tener en cuenta que el protocolo FTP no deja escribir al usuario en la carpeta raíz en la que está enjaulado. Por ello hay que tener cuidado con los permisos que otorgamos. 

Si tenemos permiso de escritura, ejecución y lectura en la raíz, al conectarnos con Filezilla nos devolverá el siguiente error:
“500 OOPS: vsftpd: refusing to run with writable root inside chroot()”

Una solución es quitarle los permisos de escritura a esa carpeta, y darle la propiedad a root. Esto hará que el usuario no pueda hacer nada en su propia carpeta, así que lo mejor es crearle otra dentro con permisos normales para que pueda utilizarla.

$ sudo chown root /home/ftp
$ sudo chmod 755 /home/ftp/usuario
$ sudo mkdir /home/ftp/usuario/personal
$ sudo chown usuario:ftpusers /home/ftp/usuario/personal

Reiniciamos el servicio "vsftp":

$ /etc/init.d/vsftpd

Ya podremos conectarnos mediante algún cliente FTP, como Filezilla, a través del usuario creado, y a su vez enjaular a éste en el directorio creado para tal uso.

Debido a que el protocolo FTP no encripta la información, estamos expuestos a que nos puedan robar fácilmente cualquier información (usuario y contraseña,…). Por ello, es recomendable sólo utilizar este protocolo en una pequeña LAN doméstica, ¡nunca fuera de ella!.

Sin embargo, en el próximo tutorial veremos cómo aumentar la seguridad  "vsftpd" y como crear y configurar certificados para asegurar un poco más las conexiones desde el exterior
.
Hasta otra….

ACCESO SSH CON CLAVE PÚBLICA/PRIVADA EN RASPBERRY Pt.2

Hoy veremos cómo conectarnos por SSH con clave pública mediante nuestro dispositivo Android.

Antes deberemos descargarnos e instalar el programa "Connectbot" desde Googleplay.

Una vez instalada abrimos  la aplicación, hacemos click en el menú  Administrar claves públicas>generar.

Elegimos el nombre del archivo, el tipo de encriptación (RSA, DSA,..), número de bits y por último la passphrase. Esta última no se debe tener en blanco por razones de seguridad  (si nos roban el móvil por ejemplo).

En el proceso de generación de las claves, nos aparecerá una ventana por el que deberemos pasar el dedo para conseguir un proceso aleatorio.

Observamos cómo se ha creado nuestra nueva clave. Si pinchamos sobre ella la desbloquearemos para utilizarla.

Presionaremos sobre la clave y nos saldrá un menú en el cual elegiremos la opción de copiarla.

Es hora de exportarla a nuestra raspberry. Volvemos al menú inicial e introducimos la información de nuestra raspberry para conectarnos vía SSH (ip, nombre usuario, puerto,…).

La lista de claves aceptados para este usuario se almacena en el archivo authorized_keys. Este archivo se encuentra en el directorio .ssh dentro del directorio principal del usuario. 

Utilice el comando echo y pegamos  la clave presionando unos segundos. Los símbolos >> añadirá la clave pública en el último párrafo  del archivo .ssh / authorized_keys.

$ echo "pegar_clave" >> .ssh / authorized_keys

Tendremos ahora que otorgar los permisos necesarios (si aún no los tiene) para que el cliente compruebe las claves. El archivo .ssh / authorized_keys debe ser escribible únicamente por el propietario. Establezca los permisos a 644 lo que significa rw-r - r--:

chmod 644 .ssh / authorized_keys

Desconectamos la sesión y volvemos  a conectar. Nos pedirá si queremos conectarnos con nuestra clave y aceptamos (es importante tener desbloqueada dicha clave).

Si el dispositivo se pierde o está inhabilitado en cualquier momento, podemos borrar la clave del servidor en el archivo authorized_keys. Utilice cualquier editor de texto, o el comando sed, para encontrar la línea adecuada:

cd ~ / .ssh

sed '/ nombre_clave $ / d' authorized_keys | tee authorized_keys

De esta forma hemos elminado nuestra clave pública del servidor.

ACCESO SSH CON CLAVE PÚBLICA/PRIVADA EN RASPBERRY Pt.1

SSH permite utilizar un gran abanico de formas de autenticación diferentes al clásico usuario/contraseña.
En este tutorial utilizaremos el método de clave pública/privada.
Esta fórmula es útil por ejemplo para crear tareas programadas entre dos servidores (backups,..). También permite que el cliente ssh pueda verificar que el servidor  al que se conecta es el genuino y no es suplantado gracias a la clave pública instalado en ambos.
De esta forma no necesitaremos introducir ninguna contraseña, ya que será la clave publica la que encriptará y clave privada la que desencriptará los datos. 
Pongámonos manos a la obra. Nos conectaremos al cliente con el que queramos establecer la conexión con la Raspberry.
En mi caso he elegido mi NAS WDMYCLOUD con el que hago las copias de seguridad de mis archivos. Tenemos que generar dos claves: una pública que tendrá cliente y servidor y otra privada que sólo tendrá el cliente. 
accedemos al terminal del nas y escribimos:

$  ssh-keygen -t dsa -b 1024 -f .ssh/mykey

SSH implementa la autenticación con clave pública utilizando RSA o DSA como algoritmos de encriptación.
A continuación se  generaran ambas claves y nos pedirá que introduzcamos una clave para el passphrase. Podemos dejarlo en blanco aunque no es recomendable. 

Ya tendremos nuestras claves generadas en el directorio .ssh de nuestro "home". En caso de que nos de error porque no exista el directorio .ssh, lo creamos y repetimos la acción.

Vemos ahora las opciones que hemos utilizado:

-b: establece el número de bits en la clave. Por defecto es 1024.
-f: crea el nombre y directorio del fichero de clave.

Es importante asignar bien los permisos para que funcione la comunicación entre los servidores a través de las claves y para mantener un grado mínimo de seguridad. Estos quedarían de la siguiente forma:

-El directorio .ssh debe tener permisos 700.
-El archivo "mykey" es la clave privada y debe tener permisos restrictivos (600).
-El archivo "mykey.pub" es la clave pública y debe tener permisos 644 para que el servidor pueda comparar ambas claves públicas.
Tenemos que verificar también que los usuarios y grupos propietarios de todos estos archivos deben ser siempre el usuario con el que vamos a conectarnos vía SSH.
Ya tenemos nuestras claves creadas y configuradas en el dispositivo cliente. Solo falta ahora exportar la clave pública "mykey.pub".
En nuestra Raspberry debemos crear el directorio .ssh dentro del "home" del usuario con el que nos vamos conectar a través del cliente (si no existe). Los permisos deben ser restrictivos (700):

$ mkdir  /home/usuario/.ssh $ chmod 700 /home/usuario/.ssh

Dentro de este directorio debemos crear el archivo "authorized_keys", que almacenará  todas las claves publicas de los diferentes clientes que se conecten al servidor, y que el cliente tendrá también que verificar:

$ touch  /home/usuario/.ssh/authorized_keys $ chmod 644 /home/usuario/.ssh/authorized_keys

El último paso es copiar el contenido de nuestra clave en el archivo authorized_keys que se encuentra en /home/usuario/.ssh de nuestro servidor Raspberry.
 Para ello abrimos el fichero local y mediante ssh lo copiamos en la última fila del archivo authorized_keys:

cat .ssh/id_dsa.pub | ssh usuario@ ip_o_nombre_de_raspberry "cat >> .ssh/authorized_keys"

Antes de probar las claves, es necesario verificar que el servidor SSH lo permita. Abrimos el archivo /etc/ssh/sshd_config con nuestro editor y descomentamos lo siguiente:

PubkeyAuthentication yes # habilitamos la autenticación por clave pública AuthorizedKeysFile .ssh/authorized_keys # indicamos la ruta de las claves. RSAAuthentication yes # si el algoritmo es tipo RSA DSAAuthentication yes # si el algoritmo es tipo DSA

Guardamos el archivo y reiniciamos el servicio SSH:

/etc/init.d/ssh restart

Ya podremos acceder a nuestra Raspberry Pi 2 mediante SSH sin introducir contraseña.
En el próximo tutorial veremos cómo configurar y generar claves ssh para Windows (Putty) y Android (Connectboot).

ACCESO SSH A RASPBERRY PI

"SSH (Secure SHell, en español: intérprete de órdenes segura) es el nombre de un protocolo y del programa que lo implementa, y sirve para acceder a máquinas remotas a través de una red. Permite manejar por completo la computadora mediante un intérprete de comandos, y también puede redirigir el tráfico de X para poder ejecutar programas gráficos si tenemos ejecutando un Servidor X (en sistemas Unix y Windows)."

Acceder a nuestra Raspberry de manera remota es una solución cómoda para administrarla de manera segura.
SSH usa técnicas de cifrado que hacen que la información de la comunicación entre emisor y receptor sea ilegible, con lo que evitamos que terceras personas puedan extraer datos comprometidos (contraseñas, comandos,...).

Nuestra Raspberry tiene instalada de fábrica  el servidor y el cliente Openssh. Lo podemos comprobar accediendo a la configuración del dispositivo mediante:

$sudo raspi-config

En opciones avanzadas>ssh podemos activar o desactivar  el servicio.

Si tenemos instalado el paquete "chkconfig" también podemos ver si este servicio está operativo:

$ sudo chkconfig | grep ssh

Una vez activado, cualquier usuario del sistema puede ya conectarse via ssh. Podemos acceder a nuestra Raspberry mediante cualquier cliente ssh (como por ejemplo putty).
Solo tendremos que introducir nuestra ip o nombre del dispositivo y el puerto correspondiente (por defecto el protocolo ssh utiliza el puerto 22):



















Sin embargo, al acceder de manera remota comprometemos de manera directa nuestra seguridad. Por ello, hay que tener en cuenta ciertos aspectos que deberemos analizar:

- ¿Qué usuarios pueden conectarse a la Raspberry?.
- ¿Desde que ips puede escuchar nuestro servidor?.
- ¿Podemos evitar ataques de fuerza bruta?.

Para solucionar estas cuestiones, debemos configurar ciertos parametros dentro del archivo de configuración del servicio ssh. 

Abrimos el archivo con el editor nano:

$ sudo /etc/ssh/sshd_config

 Nos detendremos en los siguientes parámetros:

Port 7070   # es el puerto por donde escucha el servidor. ListenAddress 192.168.0.122 # ips de escucha de peticiones PermitRootLogin no   # acceso del usuario root AllowUsers  pepe   # Usuarios que podran conectarse LoginGraceTime 30 # Tiempo de autenticación en segundos

Observamos como hemos cambiado:

-El puerto de escucha del 22 al 7070.
-La restricción de ips que se pueden conectar a una sola.
-La prohibición para que el usuario root no pueda loguearse.
-La restricción de usuarios que pueden conectarse a uno solo (pepe).
-El tiempo a 30 segundos después de que una solicitud de conexión al servidor espere antes de desconectar si el usuario no ha iniciado sesión correctamente. 

Configura los parámetros a tu gusto y si alguno no está incluido añadelo.

Con ésto la comunicación con el servidor ssh Raspberry será más segura. Si quieres acceder desde fuera de tu Lan tendrás que abrir el puerto que hayas elegido (por defecto puerto 22) para el servidor SSH  en tu router.

Un saludo.