Translate

viernes, noviembre 18, 2016

Crear un backup de la tarjeta SD de nuestra Raspberry Pi




Como ya sabreis desconectar la Raspberry Pi de la fuente de alimentación en caliente, es decir, con el sistema operativo en marcha, o incluso un corte en el suministro eléctrico de vuestra casa, puede corromper el sistema de archivos de latarjeta SD que hace de disco duro y arruinar todas las horas de trabajo que le hemos dedicado a nuestro proyecto. Esto se debe a que existen una serie de procesos críticos realizados a nivel de software en el momento de cierre del sistema operativo.
backup-raspberry-pi-os
En este tutorial aprenderemos a crear un backup (copia de seguridad) de la tarjeta SD de dos formas distintas, una de ellas se realiza desde la terminal de la propia Raspberry y la otra mediante una aplicación para Windows llamada Win32DiskImager. Esta aplicación permite tanto crear copias de seguridad como grabarlas de nuevo a una tarjeta SD por lo que deberíamos tenerla siempre a mano ya que facilita el trabajo, sobretodo a los que vienen de Windows y no estan acostumbrados a usar la terminal.

Backup desde la terminal

Para crear un backup de la tarjeta SD desde la terminal usaremos el comando dd que nos creará una copia idéntica de los archivos y dispositivos que indiquemos a un archivo .img listo para ser regrabado. Tan solo debemos escribir estos 2 comandos en la terminal:
En primer lugar desmontamos la partición /boot (/dev/mmcblkp01) y / (/dev/mmcblkp02) para evitar errores y en segundo lugar clonamos la tarjeta SD. El parámetro if indica el origen, el parámetro of el destino y bs=1 indica a dd que transfiera los datos en bloques de 1MB, con esto reducimos el tiempo que tarda en grabar la imágen a 4 minutos aproximadamente para una tarjeta Kingston de 4 GB (~1 minuto por GB). También podemos realizar la operación a la inversa e intercambiar los parámetros if y of para grabar un backup que tengamos hecho a la tarjeta SD.

Backup con Win32DiskImager

Win32DiskImager es una aplicación para Windows que nos permite hacer backups y escribirlos de nuevo, tan solo hay que seleccionar la unidad de la tarjeta SD y el nombre de archivo de la imagen. Este porgrama es mucho más sencillo de usar y nos evita el uso de la terminal, pero requiere de un pc Windows con lector de tarjetas. Podeis descargarlo gratis desde aqui: Win32DiskImager.
Crear un backup de la tarjeta SD

Backup de las bases de datos

Si teneis bases de datos MySQL en la Raspberry Pi y quereis hacer una copia de seguridad aparte podeis utilizar el comando mysqldump en la terminal:
Este comando crea una copia de seguridad de la base de datos “nombre_base_de_datos” a un archivo llamado “archivo_de_destino.sql”. Tened en cuenta que en este caso no indicamos ni el nombre de usuario ni la contraseña, para hacerlo usaremos este comando:

Backup de la carpeta home

Para hacer copias de seguridad de la carpeta /home/ se puede usar el comando tar y guardar una copia de la misma en el ordenador de casa. Para ello introducimos los siguientes comandos en la terminal:

jueves, noviembre 10, 2016

Conectar por SSH entre terminales sin usar passwords.

Hoy vamos a aprender cómo conectar vía SSH sin usar passwords. Pero primero antes de comenzar veremos varios conceptos importantes respecto al protocolo y las claves públicas para poder entender mejor cómo funciona todo.
¿Qué es el SSH?
SSH significa Secure SHell, es un protocolo diseñado para transmitir información de manera segura entre dos hosts a través de la línea de comandos de Unix. Para establecer la conexión se necesita un servidor SSH corriendo en el host destino, y un cliente SSH en el host origen. Las formas de conectar soportadas son a través de passwords o bien con llaves públicas, que es el método que vamos a ver hoy.
¿Para qué sirven las llaves públicas?
Las llaves SSH o en inglés “SSH keys”, permiten conectar dos hosts sin necesidad de usar passwords, para esto hace uso de dos pares de llaves, una pública y dos privadas.
Requerimientos Previos
El cliente OpenSSH debe estar instalado en el origen, y OpenSSH Server debe estar instalado en el destino. En las distribuciones Linux más populares ambos vienen preinstalados, pero por si acaso esta es una forma rápida de hacerlo:
CentOS/RHEL:

yum install openssh
yum install openssh-server

Ubuntu/Debian:

sudo apt-get install openssh-client
sudo apt-get install openssh-server

Antes de comenzar el tutorial, asumiremos que el host origen usa la IP 192.168.1.102 y el server destino usa la IP 192.168.1.103.

Generando las claves públicas

Para conectar sin password usaremos llaves públicas, debes generarlas en tu host origen primero usando el comando ssh-keygen:

ssh-keygen
Seguramente te pedirá que ingreses una frase segura (passphrase)  para tu llave privada, en ese momento no escribas nada y dejalo en blanco por ahora, simplemente presiona ENTER. Una vez finalices deberías ver algo como esto:

[user1@host ~]$ ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (/home/user1/.ssh/id_rsa): 
Created directory '/home/user1/.ssh'.
Enter passphrase (empty for no passphrase): 
Enter same passphrase again: 
Your identification has been saved in /home/user1/.ssh/id_rsa.
Your public key has been saved in /home/user1/.ssh/id_rsa.pub.

Como ves el resultado son dos archivos principales:

/home/user1/.ssh/id_rsa
que contiene la llave privada de tu máquina origen.

/home/user1/.ssh/id_rsa.pub
que contiene la llave pública.

Copiar la llave hacia el servidor SSH destino

Abre una terminal como root en el server destino y crea los directorios requeridos:

mkdir -p /home/user/.ssh
chmod 700 /home/user/.ssh
Luego usa scp para transferir tu llave pública hacia el directorio que creaste previamente:

scp -P 22 /home/user1/.ssh/id_rsa.pub user@192.168.1.103:/home/user/.ssh/authorized_keys
A tener en cuenta: 22 es el puerto por defecto de SSH, sin embargo muchos servidores lo cambian para mejorar la seguridad del sistema, en ese caso tendrás que reemplazar 22 por el puerto donde esté escuchando tu SSH.

Está todo listo para que puedas conectar sin password.

Prueba de conexión sin password vía SSH

Simplemente ingresar a tu host origen y tipea:

ssh user@192.168.1.103
Recuerda reemplazar el usuario ‘user’ y la IP ‘192.168.1.103’ con los datos reales que usarás para conectar.
En este punto ya deberías tener tu acceso ssh sin password:

[user1@host ~]$ ssh user@192.168.1.103
Last login: Wed Jun  924 15:29:59 2015 from 194.XX.XX.XX
[user1@host~]$
A partir de este momento ya deberías poder transferir archivos vía SSH también. Este es un ejemplo usando SCP:
[user1@host ~]$ scp -P 22 /tmp/archivo.txt user@192.168.1.103:/home/user/

Conclusiones

Como pudimos ver, conectar por ssh sin password es bastante fácil de implementar, sólo debes generar las llaves en el origen, copiarlas al destino y listo. Siempre asegúrate de que tienes las conexiones permitidas entre ambos hosts en caso de que uses un firewall, de lo contrario no podrás conectar.

Nota importante:
Si no conseguimos logearnos con este procedimiento hay que visualizar el log de autentificación para saber cual es el problema:

 cat /var/log/secure

Vemos cual es el error en este caso 
"Authentication refused: bad ownership or modes for directory /home/usuario"

Lo solucionamos dando permiso de escritura al grupo:
 chmod g-w /home/usuario
y verificamos que el resto de permisos estén bien para la carpeta .ssh:
chmod 700 /home/usuario/.ssh
chmod 600 /home/usuario/.ssh/authorized_keys



viernes, noviembre 04, 2016

Verificar bloques (clusters) malos en un disco duro Linux (ext4)

Verify bad blocks hard disk Linux (ext4)

Opción 1 (Durante el formateo):
$ mkfs.ext4 -c /dev/sda1
Opción 2 (En cualquier momento, después del formateo):
$ umount /dev/sda1
$ fsck.ext4 -cDfty -C 0 /dev/sda1
Run a ext4 file system check and badblocks scan with progress info
Nothing fancy, just a regular filesystem scan that calls the badblocks program and shows some progress info. The used options are:
  • -c ? check for bad sectors with badblocks program
  • -D ? optimize directories if possible
  • -f ? force check, even if filesystem seems clean
  • -t ? print timing stats (use -tt for more)
  • -y ? assume answer ?yes? to all questions
  • -C 0 ? print progress info to stdout
  • /dev/sdxx ? the partition to check, (e.g. /dev/sda1 for first partition on first hard disk)
NOTE: Never run fsck on a mounted partition!

miércoles, septiembre 21, 2016

Servidor VPN en Raspberry Pi (IPSec)

El objetivo es crear tunel para que nuestro dispositivo móvil pueda conectarse a Internet de forma cifrada y segura. Si además tenemos acceso a los recursos de la red local, mejor. Esta vez el cifrado será más sólido.
Los programas que hay que instalar en son: openswan que se encarga de IPSec, xl2tpd  que se encarga del transporte de datos y ppp que se encarga del tunel. Para instalarlos basta con la orden
$ sudo apt-get install openswan xl2tpd ppp
El trabajo duro es el de configuración. Primero IPSec. Hacemos una copia del fichero original y luego lo editamos para que sea cómo el ejemplo:
$ sudo cp /etc/ipsec.conf /etc/ipsec.conf.original
$ sudo nano /etc/ipsec.conf
config setup
    nat_traversal=yes
    protostack=netkey
    plutostderrlog=/tmp/log.txt

conn L2TP-PSK
    authby=secret
    pfs=no
    rekey=no
    type=tunnel
    esp=aes128-sha1
    ike=aes128-sha-modp1024
    ikelifetime=8h
    keylife=1h
    left=10.0.1.205
    leftnexthop=%defaultroute
    leftprotoport=17/1701
    right=%any
    rightprotoport=17/%any
    rightsubnetwithin=0.0.0.0/0
    auto=add
    dpddelay=30
    dpdtimeout=120
    dpdaction=clear
Los detalles que se pueden personalizar son la dirección IP del servidor en la red local y si queremos limitar el acceso desde algunas direcciones. Lo mejor es dejar %any y no complicarse la vida. Otro detalle a respetar es la indentación: cada apartado comienza en la primera línea y todo su contenido esta tabulado hacia la derecha.
Lo siguiente es definir el “secreto” una contrasenya que todas las conexiones han de conocer. Editamos el fichero ipsec.secrets:
$ sudo nano /etc/ipsec.secrets
%any %any: PSK "cHc0J#7-t4H2sU01OC"
Desde luego que puedes poner tu “secreto” y limitar para que redes u ordenadores valdrá este. Pero cómo antes es mejor no poner limitaciones.
En tercer lugar hay que configurar el protócolo de transporte xl2tp. Hacemos una copia de seguridad y editamos el fichero has que quede como el ejemplo:
$ sudo cp /etc/xl2tpd/xl2tpd.conf /etc/xl2tpd/xl2tpd.conf.original
$ sudo nano /etc/xl2tpd/xl2tpd.conf
En tu fichero debes indicar la dirección de tu servidor y el rango de IP que les daremos a los dispositivos móviles.
[global]
auth file = /etc/l2tpd/l2tp-secrets
debug network = yes
debug tunnel = yes

[lns default]

ip range = 10.0.1.209-10.0.1.240
local ip = 10.0.1.205
require chap = yes
refuse pap = yes
require authentication = yes
name = felip
ppp debug = yes
pppoptfile = /etc/ppp/options.xl2tpd
length bit = yes
Hay que seguir con el fichero de opciones del tunel, ppp.
$ sudo cp /etc/ppp/options.xl2tpd /etc/ppp/options.xl2tpd.original
$ sudo nano /etc/ppp/options.xl2tpd
Es muy recomendable indicar un servidor DNS para nuestra conexión, he escogido el servidor IP de google (8.8.8.8)
ipcp-accept-local
ipcp-accept-remote
ms-dns 8.8.8.8
noccp
auth
crtscts
idle 1800
mtu 1410
mru 1410
nodefaultroute 
debug
lock
proxyarp
connect-delay 5000
Después hay que añadir el usuario y contraseña que vamos a utilizar en la conexión.
$ sudo nano /etc/ppp/chap-secrets
Por ejemplo para el usuario “miyoremoto” le asignamos la contraseña “kunT6s+$5S”.
miyoremoto    *    kunT6s+$5S   *
¡Mucha atención! Los espacios entre las palabras en realidad han de ser tabuladores.
Para acabar la configuración el Raspberry Pi, hay que reiniciar los servicios implicados:
 $ sudo service ipsec restart
 $ sudo service xl2tpd restart
 $ sudo service pptpd restart
Casi para acabar, un detalle muy importante, nuestro servidor Raspberry Pi ha de ser capaz de redirigir los datos entre Internet y nuestro dispositivo. Para ello hemos de editar el fichero sysctl.conf
$ sudo nano /etc/sysctl.conf
Editando el fichero para asegurar que la linea ipforwarding no esté comentada.
net.ipv4.ip_forward=1
Se guarda el fichero y se reinicia el servicio,
$ sudo sysctl -p
Con esto está acabado el trabajo en el Raspi, pero falta el router…

Abrir puertos en el router

Todavía falta un detalle muy, muy importante. Que desde el exterior de nuestra red local se pueda acceder al servidor.  En concreto hay que abrir tres puertos UDP:
  • 500/udp
  • 4500/udp
  • 1701/udp
En las entradas de Acceso remoto ya expliqué cómo se hace en un Airport Extreme y enlace a información sobre otros routers, de forma que no noy a repetirme.

Configuración iPhone

Cómo el objetivo de todo el montaje era utilizar el raspi como servidor y tunel para el iPhone veamos cómo se tiene que configurar. Para ello nos hará falta:
  • Un nombre para la conexión (p.e. Raspi IPSec)
  • IP pública de nuestro Raspi (o nombre) (p.e. 81.34.123.213)
  • El nombre de usuario que hemos escogido (p.e. miyoremoto)
  • La contraseña (p.e. kunT6s+$5S)
  • El secreto de la conexión ( p.e. cHc0J#7-t4H2sU01OC)
Con estos datos vamos a los ajustes de VPN. Estos ajustes en la versión actual de IOS estan en General | VPN. Creamos una nueva VPN. Hay que seleccionar la pestaña L2TP y rellenar con los datos anteriores.
VPN IPSec en iPhone
VPN IPSec en iPhone
Con esto nuestra servidor VPN esta totalmente a punto.

Más información: