Inutile dire che on-line ci sono occhi e orecchie ovunque. Una VPN (virtual provate network) vi aiuta a navigare su Internet in modo più sicuro ed anonimo, facendo passare il vostro traffico attraverso un server fidato che non è il vostro reale punto di origine. In pratica darete l’illusione di essere in un posto differente da quello da cui in realtà vi collegherete e tutti i vostri dati saranno adeguatamente cifrati.

Utilizzare una VPN “fatta in casa” vi darà inoltre l’indubbio vantaggio di poter accedere in modo sicuro ai files ed ai media che sono sui vostri computer o nei vostri NAS, esattamente come se foste seduti sul divano del salotto o davanti alla vostra scrivania di lavoro: spesso infatti una VPN rappresenta una valida alternativa ai servizi cloud più costosi.

Ultimo vantaggio è che usando una VPN su un dispositivo mobile, è possibile sfruttare servizi e siti che in alcuni casi sono esclusivamente permessi agli utenti desktop.

E’ facile trovare offerte di VPN già pronte per l’uso, ognuna con piani di costo e livelli di sicurezza differenti. Ma con circa 40 euro (il costo di un Raspberry Pi) potrete costruirvi una propria VPN con un server (piccolo ed a basso consumo) presso casa vostra.

C’è da fare un pochino di fatica davanti al terminare shell: ma provate a seguire questa guida passo-passo e nel giro di 30 minuti avrete la vostra VPN personale!

Ingredienti

• 1 x Raspberry Pi 2 o l’ultima versione 3
• 1 x 8GB micro SD card
• 1 x SD card reader
• 1 x 5 volt mini USB power supply (va bene un carica batterie da cellulare)
• 1 x HDMI monitor (la vostra TV o il vostro monitor consueto)
• 1 x USB keyboard
• 1 x Ethernet network cable (almeno Cat5e o se volete usare la rete Gigabit Cat6)

Ovviamente do per scontato che abbiate un computer, un accesso ad internet attraverso un router, un minimo di conoscenza di reti e linux (molto minimo), un po’ di tempo da spendere e la voglia di sbagliare e ricominciare (come sempre con Linux). Potete comprare tutti gli ingredienti singolarmente oppure in kit. Di seguito qualche link amazon.it da cui partire:

Installiamo il SO sul Raspberry Pi

Inserite l’SD card nel vostro computer. Se state riutilizzando una vecchia SD assicuratevi che sia correttamente formattata per rimuovere tutti i precedenti files. Potete usare lo strumento ufficiale gratuito presso http://sdcard.org.

Scaricate NOOBS (New Out Of the Box Software) dal sito ufficiale di Raspberry Pi (https://www.raspberrypi.org/downloads/). Questo è il modo più semplice per installare un SO sulla vostra scheda.

Aprite il file .zip appena scaricato, selezionate tutti i files e copiateli nella schedina SD.

A questo punto inserite la scheda SD all’interno del Raspberry Pi, collegate monitor, tastiera, cavo di rete (per una VPN è sconsigliato usare il WiFi) ed alimentatore. Accendete.

Se tutti i files sono stati correttamente copiati, vedrete lampeggiare un led verde sulla scheda: dopo alcuni secondi sul monitor vi verrà presentata una lista di sistemi operativi e applicazioni che potrete decidere di installare: usate le frecce e scegliete Raspbian.

Per i più esperti, è disponibile direttamente la ISO di Raspian sul sito ufficiale di raspberry Pi (https://www.raspberrypi.org/downloads/)

Primo contatto

Aspettate che il processo sia finito: vi troverete davanti un ambiente grafico (molto semplice) in stile Linux. Da questo momento potete procedere con monitor e tastiera, oppure potrete lavorare via shell direttamente sul vostro computer: switchare continuamente tra il monitor del PC ed il monitor del Raspberry Pi potrebbe infatti risultare piuttosto frustrante.

Il Raspberry Pi è infatti gestibile da remoto (quindi senza tastiera e monitor) attraverso una connessione SSH. Chi dispone di Mac o Linux ha già disponibile via terminale un client SSH. Chi usa Windows può utilizzare una applicazione chiamata PuTTY (j.mp/DLPutty).

Aprite il terminale e digitate:

ssh pi@raspberrypi

La password di default è: raspberry

Se tutto va bene il prompt diventerà:

pi@raspberrypi:~ $

Nota: in genere il servizio SSH è già attivo sul SO Raspbian. Nel caso non lo fosse dovrebbe abilitarlo esplicitamente. Il modo più semplice è aprire il terminale direttamente sul vostro Rapsberry Pi e digitare:

sudo raspi-config

Quindi navigate su:

Advanced Options > SSH e scegliete Enable (abilita)

Password

cambiamo la password di default con il comando:

passwd

Vi verrà chiesta la vecchia password e due volte la nuova:

pi@raspberrypi:~ $ passwd
Cambio password per pi.
Password UNIX (corrente):
Immettere nuova password UNIX:
Reimmettere la nuova password UNIX:
passwd: password aggiornata correttamente

Riavviate con:

sudo reboot

Ricollegatevi via SSH.

IP statico sulla rete locale

Ora è necessario che il vostro raspberry abbia sempre lo stesso IP nella vostra rete locale: in genere questo potrebbe cambiare ad ogni riavvio. Digitate il comando:

ifconfig

in modo da capire le attuali impostazioni della rete. Evidenzio le informazioni rilevanti:

pi@raspberrypi:~ $ ifconfig
eth0
Link encap:Ethernet HWaddr b8:27:eb:f6:bf:f3
inet addr:192.168.1.33 Bcast:192.168.1.255 Mask:255.255.255.0
inet6 addr: fe80::9172:8a01:efdd:b7d/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:91 errors:0 dropped:0 overruns:0 frame:0
TX packets:99 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:9955 (9.7 KiB) TX bytes:14636 (14.2 KiB)

lo
Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
inet6 addr: ::1/128 Scope:Host
UP LOOPBACK RUNNING MTU:65536 Metric:1
RX packets:200 errors:0 dropped:0 overruns:0 frame:0
TX packets:200 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:16656 (16.2 KiB) TX bytes:16656 (16.2 KiB)

Ovviamente voi dovrete usare i valori restituiti dai vostri comandi, sostituendo agli IP dell’esempio, gli IP della vostra rete!!

• inet addr [Current IP Address]: 192.168.1.33
• bcast [Broadcast Range]: 192.168.1.255
• mask [Subnet Mask]: 255.255.255.0

Digitate il comando:

sudo route -n

per recuperare le altre informazioni necessarie:

pi@raspberrypi:~ $ route -n
Kernel IP routing table
Destination   Gateway      Genmask        Flags Metric Ref  Use Iface
0.0.0.0       192.168.1.1  0.0.0.0        UG    202    0    0   eth0
192.168.1.0   0.0.0.0      255.255.255.0  U     202    0    0   eth0

Qui troverete:

• Gateway: 192.168.1.1
• Destination: 192.168.1.0

Ora è necessario modificare il file di configurazione della rete di Raspbian. Useremo l’editor di testi nano per modificare il file interfaces. Digitate il comando:

sudo nano /etc/network/interfaces

Cercate la riga in cui compare:

iface eth0 inet dhcp

oppure

iface eth0 inet manual

Sostituite la parola dhcp oppure la parola manual con static:

iface eth0 inet static

Aggiungete subito dopo la riga modificata le seguenti nuove righe:

address 192.168.1.33
netmask 255.255.255.0
network 192.168.1.0
broadcast 192.168.1.255
gateway 192.168.1.1

Per salvare premete CTRL+X (insieme) e rispondete SI (Y oppure S). Quando vi verrà chiesto se volete cambiare il nome al file, accettate senza modificare nulla.

NOTA: Un modo semplice per imporre un IP statico al vostro RaspberryPi sarebbe quello di farlo attraverso il vostro router (e quindi evitare i cambiamenti appeni descritti): è infatti possibile associare un IP al MAC Address del dispositivo connesso alla rete in modo che il router assegni sempre lo stesso. In questo caso le impostazioni di rete del vostro raspberry dovranno rimanere su DHCP.

Aggiornamento

Ora è necessario assicurarsi che il SO sia aggiornato all’ultima versione. Digitate:

sudo apt-get update

Aspettate che abbia terminato e poi proseguite con:

sudo apt-get upgrade

Se volete anche assicurarvi di avere l’ultima versione del firmware del Raspberry potete usare questi ulteriori due comandi:

sudo apt-get install rpi-update
sudo rpi-update

Una volta finito, siete pronti per creare la vostra VPN.

IP statico su internet

SCORCIATOIA: DDClient impostato sul router Alcuni router dispongono di un servizio DDClient integrato. In questo modo potete evitare di installare il servizio sul Raspberry Pi, ed utilizzare quello già disponibile. Vi basta accedere alle configurazioni avanzate e cercare DDNS (o qualcosa del genere): inserite le vostre credenziali ed il dominio e sarà direttamente il vostro touter a preoccuparsi di aggiornare l’associazione tra IP dinamico pubblico e dominio.

Per utilizzare la vostra VPN è necessario che un client autorizzato sia in grado di trovare il vostro server su Internet: per questo vi serve un indirizzo pubblico che non cambi con il tempo. In teoria sarebbe il vostro indirizzo IP pubblico (cioè su internet), che normalmente dovrebbe essere tenuto segreto in quanto identifica la vostra posizione nella rete.

Voi potete scoprire il vostro IP pubblico attraverso alcuni siti come whatismyip.com, oppure whatismyipaddress.com.

Il problema è che (a meno di casi particolari) questo indirizzo cambia di continuo (per esempio ad ogni accensione del vostro router) e sarà necessario utilizzare un servizio DDNS (dynamic domain name system) che vi fornirà un nome di dominio (che non cambia) da usare al posto dell’indirizzo IP pubblico.

Esistono moltissimi servizi gratuiti, come changeip.com oppure dtdns.com: per poterli utilizzare, una volta registrati, dovrete eseguire e configurare uno specifico client sul vostro Raspberry Pi (DDClient) in modo da aggiornare automaticamente il registro del DDNS. In pratica questo client non farà altro che associare il vostro IP (che cambia) con un nome di dominio fisso. Digitate:

sudo apt-get install ddclient

Questo avvierà un wizard per la configurazione del client. Potete anche non preoccuparvi molto di quello che inserirete in questa fase. Molto più comodo, infatti, è editare il file di configurazione:

sudo nano /etc/ddclient.conf

Ogni servizio ha una sua differente configurazione, ma in sostanza vi servono le credenziali del servizio (username e password) ed il nome di dominio scelto: nel nostro caso (è un esempio) scegliamo subdomain.domain.com. Un esempio con dyndns.it:

protocol=dyndns2
server=dynupdate.no-ip.com
login=yourloginid
password='yourpassword'
use=web,web=checkip.dyndns.com/,web-skip='IP Address'
subdomain.domain.com

Se usate changeip.com fate riferimento a queste indicazioni. Salvate (CTRL+X) e uscite (S, ENTER). Quindi avviate il client:

sudo ddclient

Per l’autostart e l’avvio come demone di DDClient editate il files /etc/default/ddclient:

# Configuration for ddclient scripts
# generated from debconf on Mon Jun 29 00:31:50 PDT 2015
#
# /etc/default/ddclient

# Set to "true" if ddclient should be run every time DHCP client ('dhclient'
# from package isc-dhcp-client) updates the systems IP address.
run_dhclient="false"

# Set to "true" if ddclient should be run every time a new ppp connection is
# established. This might be useful, if you are using dial-on-demand.
run_ipup="false"

# Set to "true" if ddclient should run in daemon mode
# If this is changed to true, run_ipup and run_dhclient must be set to false.
run_daemon="true"

# Set the time interval between the updates of the dynamic DNS name in seconds.
# This option only takes effect if the ddclient runs in daemon mode.
daemon_interval="1800"

Quindi riavviate il servizio con:

sudo systemctl enable ddclient

Port Forwarding del router

Abbiamo un indirizzo pubblico, ma non è ancora sufficiente. Dobbiamo fare in modo che il router faccia passare il traffico proveniente da internet e destinato al nostro server OpenVPN verso l’indirizzo locale corretto. In genere i router hanno un firewall che blocca tutte le connessioni in ingresso: nello specifico dobbiamo fare in modo che il traffico sulla porta UDP 1194 (che è la porta standard di OpenVPN) sia correttamente fatto passare dalla rete esterna alla rete interna. Si tratta di un regola di port forwarding da inserire nel vostro router.

Di fatto state aprendo un piccolo buco nelle difese della vostra rete domestica per far passare solo un tipo di traffico e solo verso una macchina specifica.

Ogni router è diverso, per cui vo consiglio ricercare su internet le istruzioni adatte per il vostro. Spesso però le impostazioni necessarie si trovano in

Configurazione avanzata > Port forwarding / Port Triggering / Port mapping

Una volta trovato il posto giusto, si imposta una regola con i seguenti parametri:

• Protocollo: UDP
• Porta esterna: 1194
• Porta interna: 1194
• Nome: OpenVPN (se necessario)

Sarà possibile verificare che il tutto sia configurato correttamente più tardi, quando ci occuperemo del server OpenVPN.

NOTA: è possibile cambiare la porta ed il protocollo usatila OpenVPN. La scelta dell’UDP 1194 non è obbligata. Per impostazione predefinita OpenVPN Access Server dispone di 2 daemon OpenVPN in esecuzione. Uno di loro sulla porta UDP 1194 e un altro su TCP 443. Si consiglia di utilizzare la porta UDP perché questo funzioni meglio per un tunnel OpenVPN. Tuttavia, molti luoghi pubblici bloccano tutti i tipi di porte, tranne quelli molto comuni come HTTP, HTTPS, FTP, POP3, e così via. Per questo è disponibile come opzione la TCP 443 che è la porta predefinita per HTTP/SSL.
Se poi volete utilizzare una porta completamente differente potete farlo.

Installiamo OpenVPN

Per realizzare la nostra VPN installeremo ed utilizzeremo il pacchetto OpenVPN. Digitate:

sudo apt-get install openvpn

Seguite le istruzioni: il pacchetto sarà scaricato, decompresso ed installato. Riavviate con:

sudo reboot

Installiamo Easy_RSA

Esattamente come una chiave che apre la porta principale di casa vostra, la VPN ha bisogno di generare le proprie chiavi per assicurarvi che solo i dispositivi autorizzati possano collegarsi ad essa. Al fine di connette in modo sicuro due computer, OpenVPN utilizza infatti chiavi che forniscono lo strato di autenticazione e di sicurezza. E ‘importante proteggere le chiavi che stiamo per generare assicurandoci che nessuno possa accedervi.

E’ necessario installare Easy_RSA, un pacchetto semplice che vi permetterà di usare la cifratura RSA e generare chiavi univoche.

sudo apt-get install easy-rsa

La prossima serie di comandi devono necessariamente essere eseguiti con privilegi di super amministratore (root). Fino a questo momento il vostro prompt recitativa:

pi@raspberrypi: ~ $

Digitando sudo prima di un comando, voi dite al sistema operativo di eseguirlo con privilegi di amministratore, nella cartella root. Dovendo digitare moti comandi, per evitare di scrivere in continuazione sudo + comando, digitiamo una volta per tutte:

sudo -s

Il prompt cambierà definitivamente in:

root@raspberrypi

Ora dovete creare una cartella che sia in grado di ospitare i vostri certificati (si tratta di cartelle speciali):

make-cadir /etc/openvpn/easy-rsa

Copiamo in questa cartella i files di EasyRSA che dovranno essere editati: in questo modo avremo a disposizione un backup nel caso qualcosa andasse storto:
cp -r /usr/share/doc/openvpn/examples/easy-rsa/2.0 /etc/openvpn/easy-rsa

cp -r /usr/share/easy-rsa /etc/openvpn/easy-rsa

[Correzione effettuata grazie al contributo di Andrea nei Commenti]

In pratica abbiamo copiato tutti i files da cartella easy-rss 2.0 alla nostra nuova cartella. Prossimo passo: spostiamoci di cartella e andiamo a modificare il file di testo che contiene i parametri di base, quali il percorso delle chiavi, la nostra nazione, la provincia, la città, etc.:

cd /etc/openvpn/easy-rsa
nano vars

Cercate la riga che inizia con:

export EASY_RSA=

Editatela inserendovi il percorso della cartella che avete creato prima e che conterrà i certificati. Quindi:

export EASY_RSA="/etc/openvpn/easy-rsa"

Ora spostate il cursore un po’ più sotto. Se siete paranoici, potete impostare la dimensione della chiave di cifratura a 2048 bit. Servirà molto tempo per la generazione delle chiavi, e la connessione sarà un po’ più lenta, ma potrete vivere sonni assolutamente tranquilli. Io, con un Raspberry Pi 2, tendo a a lasciarla a 1024.

export KEY_SIZE=1024

Andando ancora più giù, riempite gli ultimi parametri dettando dei nuovi defaults. Queste voci vi faranno risparmiare tempo in fase di creazione delle chiavi, ma sono di fatto ininfluenti per il corretto funzionamento della VPN.

export KEY_COUNTRY=”IT”
export KEY_PROVINCE=”Tuscany”
export KEY_CITY=”Florence”
export KEY_ORG=”mariorossispa”
export KEY_EMAIL=”mario@rossi.com”
export KEY_OU=”marioufficio”

Ovviamente sostituite i valori tra le virgolette con i vostri parametri. Per salvare premete CTRL+X (insieme) e rispondete SI (S o Y). Quando vi verrà chiesto se volete cambiare il nome al file, accettate senza modificare nulla.

Le chiavi della Certification Authority

Creiamo a questo punto i certificati che la VPN userà per garantire le autorizzazioni ai dispositivi che vorranno connettersi. Aprite la cartella easy-rsa ed eseguite i seguenti comandi:

cd /etc/openvpn/easy-rsa
source ./vars
./clean-all
./build-ca

I comandi rispettivamente servono per:

• posizionarsi nella cartella easy-rsa
• caricare il documento vars editato prima con i valori popolati;
• eliminare eventuali precedenti chiavi presenti a sistema;
• costruire la certificate authority con tanto di certificato e chiave privata

Nell’ultimo passo viene scritta la chiave privata nel file ca.key, mentre un certificato nel file ca.crt. Vi verranno chieste una serie di informazioni che però dovreste avere già popolato nel file vars.

Le chiavi del server

Dare un nome al server VPN è come dare un nome ad un proprio figlio: non si cambia e non si può scordare. Digitate:

./build-key-server ServerName

ATTENZIONE! Anche in questo caso rispondete alle domande che vi vengono poste scegliendo eventualmente di lasciare i valori di default (esattamente come nel caso precedente in cui vi chiedevano la Nazione, il Nome, etc). Fate però attenzione a due cose importanti:

• Common Name: deve essere uguale al ServerName che avete scelto;
• Challenge password: deve essere lasciata blank (vuota);

Firmate il certificato ed eseguite il commit.

Sign the certificate? [y/n]:y
1 out of 1 certificate requests certified, commit? [y/n]y

Diffie-Hellman

Lo scambio di chiavi Diffie-Hellman (Diffie-Hellman key exchange) è un protocollo crittografico che consente a due entità di stabilire una chiave condivisa e segreta utilizzando un canale di comunicazione insicuro (pubblico) senza la necessità che le due parti si siano scambiate informazioni o si siano incontrate in precedenza. Digitate:

./build-dh

Se avete scelto una profondità di 2048 bit, potreste dover aspettare circa un’ora. A 1024 bit l’operazione impiega pochi minuti.

Protezione da DoS: HMAC

OpenVPN è in grado di difendervi da attacchi di tipo Denial of Services (o anche operazioni di port Scanning, buffer overflow, etc) generando una chiave statica pre-condivisa HMAC (hash-based message code). Questo significa che il server non proverà nemmeno ad autenticare un accesso se non viene rilevata questa chiave. Per generare la chiave HMAC digitate:

cd /etc/openvpn/easy-rsa
openvpn --genkey --secret keys/ta.key

NOTA: nel momento in cui scrivo questa guida ho rilevato un probabile baco in alcuni client (in particolare l’OpenVPN Client per iOS): in pratica con la connessione 3G/LTE non viene inviata al server la chiave HMAC procurando così l’errore:

TLS Error: TLS key negotiation failed to occur within 60 seconds (check your network connectivity)
TLS Error: TLS handshake failed

Connettendo il client in WiFi invece la chiave passa e la connessione in VPN viene stabilita senza problemi. Per far funzionare il mio iPhone in LTE ho avuto come unica possibilità quella di non usare la chiave HMAC. Per questo motivo negli esempi in calce dovete commentate le righe relative a questo ulteriore strato di cifratura: in genere fanno riferimento alla meccanismo di autenticazione xls-auth.

Le chiavi del client

Il vostro server VPN è praticamente configurato. Adesso è necessario creare le chiavi per ciascun dispositivo che debba connettersi. Potreste anche decidere di usare la stessa chiave per tutti i dispositivi, ma avreste il vincolo che non si potranno connettere contemporaneamente. Creiamo, ad esempio, la chiave per il mio smartphone che chiamerò alessandroPhone (voi ovviamente usate un altro nome).

./build-key-pass alessandroPhone

Anche in questo caso vi verranno chieste alcune cose:

• PEM pass phrase: scegliete una password che dovrete ricordare. Dovrete digitarla due volte!
• Challenge password: deve essere lasciata blank (vuota);

Firmate anche questa volta il certificato ed eseguite il commit.

Sign the certificate? [y/n]:y
1 out of 1 certificate requests certified, commit? [y/n]y

Adesso nella cartella:

/etc/openvpn/easy-rsa/keys

troverete 3 files in più: alessandroPhone.crt, alessandroPhone.csr, alessandroPhone.key. Spostatevi quindi nella cartella keys e digitate:

openssl rsa -in alessandroPhone.key -des3 -out alessandroPhone.3des.key

Quest’ultima istruzione aggiunge un ulteriore strato di cifratura (3DES) in modo da rendere la vita degli hackers un po’ più complicata. Vi verrà chiesta la password scelta precedentemente. Vi verrà chiesto inoltre di generare una ulteriore password (PEM pass phrase): io vi consiglio di usare la solita, in modo da doverne ricordare solo una per certificato.

Ripetete l’operazione qui descritta per ogni utente o dispositivo a cui volete concedere l’accesso alla VPN.

Rivediamo tutte le chiavi ed i certificati

Abbiamo generato un certificato/chiave master per la CA, una chiave Diffie-Hellman, una chiave HMAC, un certificato/chiave per il server ed un certificato/chiave per ogni client (nel nostro esempio solo 1):

Vedremo successivamente come usarli.

Configuriamo il server

Ora abbiamo creato serrature e chiavi. Non ci resta che dire al Raspberry Pi dove mettere le porte. In pratica dobbiamo istruire OpenVPN ad usare le chiavi che abbiamo creato ed il giusto IP con relativa porta. Creiamo un file di configurazione a partire da un foglio bianco:

nano /etc/openvpn/server.conf

Riempitelo con il testo in calce, stando attenti a variare i dettagli come indicato dai commenti preceduti dallo sharp #:

# stessa porta configurata sul router
port 1194

# configurazione di base di OpenVPN
proto udp
dev tun

# Chiavi e certificati
ca /etc/openvpn/easy-rsa/keys/ca.crt
cert /etc/openvpn/easy-rsa/keys/ServerName.crt
key /etc/openvpn/easy-rsa/keys/ServerName.key # This file should be kept secret

# Parametri Diffie-Hellman
dh /etc/openvpn/easy-rsa/keys/dh1024.pem

# # HMAC firewall - commentato per problemi di connessione via 3G/4G
# tls-server
# tls-auth /etc/openvpn/easy-rsa/keys/ta.key 0
# tls-cipher TLS-DHE-RSA-WITH-AES-256-CBC-SHA

# configurazione degli indirizzi della VPN
server 10.8.0.0 255.255.255.0
# se un client si disconnette e si riconnette gli si
# riassegna lo stesso vecchio IP nella classe 10.8.0.0
ifconfig-pool-persist /etc/openvpn/easy-rsa/ipp.txt

# Si aggiunge una rotta tra tutti i client della VPN
push "route 10.8.0.0 255.255.255.0"

# Si aggiunge una rotta affinché i client raggiungano gli
# indirizzi locali nella propria rete dietro il router
push "route 192.168.1.0 255.255.255.0"

# DNS - Se il vostro router non fa da DNS usate quello di Google 8.8.8.8
push "dhcp-option DNS 192.168.1.1" # L'IP DEL VOSTRO ROUTER

# Traffico internet
push "redirect-gateway def1" # in questo modo si dirotta tutto il traffico via VPN
client-to-client # la connessione tra i client è punto-punto
duplicate-cn
keepalive 10 120

# cifratura
cipher AES-256-CBC
auth SHA512
key-direction 0

# compressione
comp-lzo

# massimo numero di client connessi
max-clients 5

user nobody
group nogroup

persist-key
persist-tun

# log
status /var/log/openvpn-status.log 300
log /var/log/openvpn.log
verb 1
mute 20

Cliccate su CTRL+X, uscite (S) e salvate (INVIO). Riavviate il servizio OpenVPN con:

/etc/init.d/openvpn restart

L’esempio del file di configurazione creerà una VPN usando una interfaccia di rete virtuale TUN (per il routing), si metterà in ascolto dei clients sulla porta UDP 1194 e distribuirà indirizzi IP virtuali nella sottorete 10.8.0.0/24.

NOTA: Per testare rapidamente la configurazione è sufficiente lanciare direttamente OpenVPN (assicurandosi prima di aver fermato il demone lanciato dall’init script durante l’installazione):

/etc/init.d/openvpn stop
openvpn server.conf

Se non ricevete nessun errore allora la vostra configurazione è corretta, potete interrompere l’esecuzione con Ctrl+C.

Autostart di OpenVPN Server

Editate il file /etc/default/openvpn con:

nano /etc/default/openvpn

Eliminate il commento nella riga che contiene AUTOSTART e inserite il nome del vostro file di configurazione del server (appena creato):

...
AUTOSTART="server"
...

Riavviate con reboot.

Configuriamo i Client

Abbiamo creato le chiavi per i client (computer e dispositivi vari) che vogliamo che si connettano alla nostra VPN. Dobbiamo però ancora dire ai nostri client dove trovare il server, come connettersi o quali chiavi usare. Ci sono due possibili impostazioni per i vostri client, che determinano il modo in cui il traffico viene gestito dalla VPN.

• FULL TUNNEL: si indirizza tutto il traffico Internet attraverso il server OpenVPN. Se ad esempio volete connettervi attraverso un hotspot pubblico ma in sicurezza. Per esempio se voleste consultare la vostra home banking, i server della vostra banca vi vedranno arrivare esattamente come se vi foste collegati da casa.Utilizzare la configurazione full tunnel è una buona idea se si desidera proteggere il 100% di tutto il traffico in uscita dal dispositivo client. Questo è il metodo utilizzato normalmente per le connessioni di utenti in paesi in cui l’accesso alla rete è fortemente regolamentata (ad esempio la Cina) o per le connessioni attraverso accessi pubblici controllati.Facendo passare tutto il traffico in modo sicuro attraverso la propria rete domestica, si ottiene lo stesso livello di sicurezza e di fiducia della propria rete domestica. Lo svantaggio qui può essere prestazionale, dal momento che la larghezza di banda è limitata dalle possibilità del vostro Raspberry Pi e dal vostro contratto internet.
• SPLIT TUNNEL: si indirizza attraverso il server VPN solo il traffico Internet che ha bisogno di raggiungere l’interno della vostra rete domestica. Ad esempio se voleste accedere al vostro NAS per vedere un film da remoto. Il nome split deriva dal fatto che il traffico ha un percorso diverso a seconda se si stia andando alla rete domestica oppure no. Tutto il traffico Internet viene quindi veicolato attraverso il gateway predefinito della vostra connessione.Usare la configurazione split tunnel è una buona idea se non siete preoccupati dal livello generale di sicurezza della vostra connessione e volete semplicemente accedere alla vostra rete di casa, magari in mobilità con il vostro smartphone o dalla rete del vostro ufficio.

Bisogna scegliere adesso? No! Si può effettivamente avere entrambi i tipi di tunnel impostati sui vostri client, e scegliere ogni volta quale utilizzare per la vostra connessione.

Personalmente per il 90% del tempo utilizzo lo split tunnel perché sono al lavoro o a casa di una persona di cui mi fido (e della cui rete mi fido): in questo modo evito di sovraccaricare la mia rete di casa. Uso invece il full tunnel quando ho bisogno di far passare informazioni sensibili, come dati finanziati o sanitari o password in chiaro. O quando devo far credere a qualcuno di essere davanti alla mia scrivania mentre uso il mio PC desktop.

Full tunnel configuration

Se avete creato differenti chiavi per ciascuno dei client (o come nel nostro caso avete differenti modalità di tunneling), potrebbe essere un po’ noioso generare un file di configurazione per ogni differente client partendo da zero. Per fortuna Eric Jodoin dell’istituto SANS ci ha preparato un comodo script.

Prima di tutto creeremo un file intermedio (diciamo di appoggio) contenente i parametri fondamentali per una connessione “full tunnel” e lo salveremo sul Raspberry Pi. Useremo questo file successivamente per produrre il file di configurazione vero e proprio da installare sul client. Apriamo l’editor di testo e creiamo quindi un file nuovo client-full.txt:

nano /etc/openvpn/openvpn/easy-rsa/keys/client-full.txt

Incolliamo il seguente testo:

# Full Tunnel OpenVPN client configuration
client
dev tun
proto udp

resolv-retry infinite
key-direction 1
nobind
persist-key
persist-tun

# cambiate 'subdomain.domain.com' con il vostro dominio
remote subdomain.domain.com 1194

# cifratura
cipher AES-256-CBC
auth SHA512

# HMAC firewall - commentato per problemi con connessioni 3G/4G
# tls-client
# tls-cipher DHE-RSA-AES256-SHA

# compressione
comp-lzo

# logging setup
mute-replay-warnings
verb 3
mute 20

Ovviamente modificate il testo con i vostri parametri come indicato nei commenti. Salvate ed uscite.

Ora creiamo il nostro primo file di profilo: un file di configurazione che contiene tutti parametri, ma anche le chiavi ed i certificati necessari a far collegare un client al Server VPN.  Creiamo lo script di Eric Jodoin che ci faciliterà il compito:

nano /etc/openvpn/easy-rsa/keys/MakeOVPN.sh

Si tratta di un altro file vuoto (nuovo) che dovete riempire così (attenzione, io l’ho un po’ modificato!):

#!/bin/bash
# Default Variable Declarations
DEFAULT="client-full.txt"
FILEEXT="-full.ovpn"
CRT=".crt"
KEY=".3des.key"
CA="ca.crt"
TA="ta.key"
#Ask for a Client name
echo "Please enter an existing Client Name:"
read NAME
#1st Verify that client's Public Key Exists
if [ ! -f $NAME$CRT ]; then
echo "[ERROR]: Client Public Key Certificate not found: $NAME$CRT"
exit
fi
echo "Client's cert found: $NAME$CR"
#Then, verify that there is a private key for that client
if [ ! -f $NAME$KEY ]; then
echo "[ERROR]: Client 3des Private Key not found: $NAME$KEY"
exit
fi
echo "Client's Private Key found: $NAME$KEY"
#Confirm the CA public key exists
if [ ! -f $CA ]; then
echo "[ERROR]: CA Public Key not found: $CA"
exit
fi
echo "CA public Key found: $CA"
#Confirm the tls-auth ta key file exists
if [ ! -f $TA ]; then
echo "[ERROR]: tls-auth Key not found: $TA"
exit
fi
echo "tls-auth Private Key found: $TA"
#Ready to make a new .opvn file - Start by populating with the default file
cat $DEFAULT > $NAME$FILEEXT
#Now, append the CA Public Cert
echo "<ca>" >> $NAME$FILEEXT
cat $CA >> $NAME$FILEEXT
echo "</ca>" >> $NAME$FILEEXT
#Next append the client Public Cert
echo "<cert>" >> $NAME$FILEEXT
cat $NAME$CRT | sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p' >> $NAME$FILEEXT
echo "</cert>" >> $NAME$FILEEXT
#Then, append the client Private Key
echo "<key>" >> $NAME$FILEEXT
cat $NAME$KEY >> $NAME$FILEEXT
echo "</key>" >> $NAME$FILEEXT
#Finally, append the TA Private Key
echo "<tls-auth>" >> $NAME$FILEEXT
cat $TA >> $NAME$FILEEXT
echo "</tls-auth>" >> $NAME$FILEEXT
echo "Done! $NAME$FILEEXT Successfully Created."
#Script written by Eric Jodoin
\ No newline at end of file

Questo file altro non fa che creare un file .opvn (cioè il profilo di configurazione del client) concatenando i parametri di default che avete impostato nel file client-full.txt, i certificati e le chiavi.

Salvate ed uscite (CTRL+ X, S, INVIO). Diamo a questo script permessi di esecuzione, e lanciamolo:

cd /etc/openvpn/easy-rsa/keys/
chmod 700 MakeOVPN.sh
./MakeOVPN.sh

Vi chiederà di inserire il nome del client per generare il profilo: nel mio caso ho inserito alessandroPhone. Verificate che tutto sia andato a buon fine:

Client's cert found: alessandroPhone
Client's Private Key found: alessandroPhone.3des.key
CA public Key found: ca.crt
tls-auth Private Key found: ta.key
Done! alessandroPhone-full.ovpn Successfully Created.

Il vostro primo files di configurazione è pronto: lo trovate nella cartella /etc/openvpn/easy-rsa/keys/ con il nome alessandroPhone-full.ovpn

NOTA: Se non volete usare la chiave HMAC commentate il blocco tls-auth che contiene questa chiave.

Qui un esempio (ho eliminato alcune delle righe dei certificati HMAC):

# Full Tunnel OpenVPN client configuration
client
dev tun
proto udp

resolv-retry infinite
key-direction 1
nobind
persist-key
persist-tun

# cambiate 'subdomain.domain.com' con il vostro dominio
remote subdomain.domain.com 1194

# cifratura
cipher AES-256-CBC
auth SHA512

# HMAC firewall - commentato per problemi con connessioni 3G/4G
# tls-client
# tls-cipher DHE-RSA-AES256-SHA

# compressione
comp-lzo

# logging setup
mute-replay-warnings
verb 3
mute 20
<ca>
-----BEGIN CERTIFICATE-----
MIID+DCCA2GgAwIBAgIJAMv1emtK+VXvMA0GCSqGSIb3DQEBCwUAMIGvMQswCQYD
(continua...)
ZuCwFXJzTTZVWRnu+LVr8c43W99ykTztPFjsmfOmuOjr6r9YzdpH93ZsRQ1jc1mp
RnFvwN9kwSRy9Hjc
-----END CERTIFICATE-----
</ca>
<cert>
-----BEGIN CERTIFICATE-----
MIIEXTCCA8agAwIBAgIBAjANBgkqhkiG9w0BAQsFADCBrzELMAkGA1UEBhMCSVQx
(continua...)
Y7bTFalm/ofiuukgtQh/IMLlXL4ED4iRr3t3yZyJh1K6qzOk7dkBYM54YjQrODyR
QgdPNSHMNPH831ewY0CuQgA=
-----END CERTIFICATE-----
</cert>
<key>
-----BEGIN RSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: DES-EDE3-CBC,460E06B24D314908

wOUkGtH56oGuNug61+BGdotGIO5FumgJL9ya7WNwVoKBxqZzZT5XAHbaxadrp8GT
(continua...)
bFjVWw7qdllVvkgl1kruDIj0CREO9abiVMTdkIyGMv7D7MQGJEXzeg==
-----END RSA PRIVATE KEY-----
</key>
# <tls-auth>
# #
# # 2048 bit OpenVPN static key
# #
# -----BEGIN OpenVPN Static key V1-----
# 6604ce27b58cbbc714d004b08b7275bf
(continua...)
# ebe07851d1fabb6c372a6c0dc316dd00
# -----END OpenVPN Static key V1-----
# </tls-auth>

 

Split tunnel configuration

Ripetiamo più o meno le stesse operazioni fatte per la connessione full: cambia ovviamente qualcosa nella configurazione.

Qui di seguito, creeremo un file intermedio (diciamo di appoggio) contenente i parametri fondamentali per una connessione “split tunnel” e lo salveremo sul Raspberry Pi. Useremo questo file successivamente per produrre il file di configurazione vero e proprio da installare sul client. Apriamo l’editor di testo e creiamo un file nuovo:

nano /etc/openvpn/openvpn/easy-rsa/keys/client-split.txt

Incolliamo il seguente testo:

# Split Tunnel OpenVPN client configuration
client
dev tun
proto udp

resolv-retry infinite
key-direction 1
nobind
persist-key
persist-tun

# cambiate 'subdomain.domain.com' con il vostro dominio
remote subdomain.domain.com 1194

# si ignora l'impostazione delle rotte del server
route-nopull
# si sovrascrive il gateway
route 0.0.0.0 192.0.0.0 net_gateway
route 64.0.0.0 192.0.0.0 net_gateway
route 128.0.0.0 192.0.0.0 net_gateway
route 192.0.0.0 192.0.0.0 net_gateway

# si aprono le rotte verso la sola propria rete locale
route 192.168.1.0 255.255.255.0

# cifratura
cipher AES-256-CBC
auth SHA512

# HMAC firewall - commentato per problemi con connessioni 3G/4G
# tls-client
# tls-cipher DHE-RSA-AES256-SHA

# compressione
comp-lzo

# logging setup
mute-replay-warnings
verb 3
mute 20

Ovviamente modificate il testo cone i vostri parametri come indicato di commenti: la vostra porta e l’indirizzamento della vostra rete locale. Salvate ed uscite.

Ora creiamo il nostro secondo profilo: un file di configurazione che contiene tutti parametri, ma anche le chiavi ed i certificati necessari a far collegare un client al Server VPN (esattamente come nell’esempio precedente). Vi basterà modificare lo script usato precedentemente. Aprite l’editor:

nano MakeOVPN.sh

e cambiate le prima righe secondo l’esempio in basso:

#!/bin/bash
# Default Variable Declarations
DEFAULT="client-split.txt"
FILEEXT="-split.ovpn"
CRT=".crt"
KEY=".3des.key"
CA="ca.crt"
TA="ta.key"

Salvate ed uscite. Eseguite lo script modificato:

./MakeOVPN.sh

Vi chiederà anche in questo caso di inserire il nome del client per generare il profilo: nel mio caso ho inserito nuovamente alessandroPhone. Verificate che tutto sia andato a buon fine:

Client's cert found: alessandroPhone
Client's Private Key found: alessandroPhone.3des.key
CA public Key found: ca.crt
tls-auth Private Key found: ta.key
Done! alessandroPhone-split.ovpn Successfully Created.

Adesso avete completato anche il secondo vostro file di configurazione: lo trovate nella cartella /etc/openvpn/easy-rsa/keys/ con il nome alessandroPhone-split.ovpn.

Stesse considerazioni del precedente caso: si tratta sempre della concatenazione del file di configurazione .txt e di tutte le chiavi generate utili al client. Analoghe considerazioni per la chiave HMAC e per il commento del blocco tls-auth che contiene questa chiave.

Esportiamo le chiavi sul dispositivo

Nel mio caso sono stati generati due files alessandroPhone-full.ovpn e alessandroPhone-split.opvn. Ora dobbiamo prelevarli dal RaspberryPi. Prima però è necessario garantirsi permessi di lettura/scrittura nella varie cartelle e sui files di profilo. Digitate:

chmod 777 /etc/openvpn
chmod 777 /etc/openvpn/easy-rsa
chmod 777 /etc/openvpn/easy-rsa/keys
chmod 777 /etc/openvpn/easy-rsa/keys/alessandroPhone-full.ovpn
chmod 777 /etc/openvpn/easy-rsa/keys/alessandroPhone-split.ovpn

Questo vi permetterà di copiare i files dal RaspberryPi. Su Windows, usando PuTTY, è possibile usare un modulo chiamato WinSCP. Io, sul MAC, preferisco la riga di comando: in questo caso aprite un’altra finestra del terminale sul vostro PC (non usate la sessione sul RaspberryPi) e digitate:

scp pi@raspberrypi:/etc/openvpn/easy-rsa/keys/alessandroPhone-full.ovpn alessandroPhone-full.ovpn
scp pi@raspberrypi:/etc/openvpn/easy-rsa/keys/alessandroPhone-split.ovpn alessandroPhone-split.ovpn

Adesso dovreste avere i files .ovpn sul vostro PC. Tornate a lavorare sul terminale del vostro Raspberry perché è opportuno rimettere tutto come prima, revocando permessi che potrebbero diventare una vulnerabilità. Usate perciò il comando:

chmod 600 /etc/openvpn
chmod 600 /etc/openvpn/easy-rsa
chmod 600 /etc/openvpn/easy-rsa/keys
chmod 600 /etc/openvpn/easy-rsa/keys/alessandroPhone-full.ovpn
chmod 600 /etc/openvpn/easy-rsa/keys/alessandroPhone-split.ovpn

IP Forwarding

A questo punto un’ultima configurazione per essere sicuri che il vostro Raspberry Pi possa conoscere come gestire l’inoltro del traffico internet attraverso la nuova rete. Digitate:

nano /etc/sysctl.conf

Trovate il seguente commento:

# Uncomment the next line to enable packet forwarding for IPv4

Rimuovete dalla riga successiva il simbolo di inizio commento (#). Che quindi diventa:

net.ipv4.ip_forward=1

Cliccate su CTRL+X, uscite e salvate. Per applicare i cambiamenti descritti nel file appena modificato digitate:

sysctl -p

Firewall

Raspbian ha un firewall integrato (IPTable) che bloccherà tutte le connessioni in ingresso: è quindi necessario permettere al traffico autorizzato di attraversare OpenVPN. Creiamo perciò un file che verrà eseguito ogni volta all’avvio del sistema:

nano /etc/firewall-openvpn-rules.sh

Dentro questo file scriviamo:

#!/bin/sh
iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

In pratica abbiamo aggiunto una policy al firewall. Cliccate su CTRL+X, uscite e salvate.

Questo file non ha ancora i diritti per essere eseguito. Dovete perciò cambiargli sia i permessi che la proprietà (che imposterete a root). Per fare questo:

chmod 700 /etc/firewall-openvpn-rules.sh

chown root /etc/firewall-openvpn-rules.sh

Questo script fornisce ad OpenVPN il permesso di fare breccia attraverso il firewall. Abbiamo bisogno ora di aggiungerlo al codice che imposta le interfacce di rete in modo che possa essere avviato al boot. Digitate:

nano /etc/network/interfaces

Trovate la riga che dice:

iface eth0 inet static

Aggiungiamo alla fine della sezione (dopo tutti gli indirizzi IP che abbiamo aggiunto prima) una nuova riga. La nuova riga deve iniziare con un [TAB] in modo da indentarla:

pre-up /etc/firewall-openvpn-rules.sh

Cliccate su CTRL+X, uscite e salvate. Potete riavviare il vostro Raspberry Pi con

reboot

Installate OpenVPN sul vostro dispositivo

A questo punto siete pronti ad scaricare ed installare l’applicazione OpenVPN Connect sul vostro dispositivo iPhone o Android: importate i profili (files .ovpn), inserite la password relativa al 3des.key e connettetevi.

Per iOS ecco qualche consiglio per la parametrizzazione dell’app (Settings app → OpenVPN):

• Raise keyboard: Off
• Connect via: Any network
• Reconnect on wakeup: On
• Protocol: Adaptive
• Compression: Full
• Connection timeout: 30 seconds
• Network state detection: Active
• Force AES-CBC ciphersuites: On
• Google DNS fallback: off
• Enable Proxy: secondo la vostra rete