Gestione delle credenziali

L’autenticazione è da sempre, uno degli aspetti fondamentali dell’informatica. Spesso però la gestione delle credenziali viene trascurata, sia dai singoli utenti (power-user inclusi) che da molte realtà aziendali.

In questo post esamineremo alcuni sistemi per gestire in modo sicuro, le credenziali per accedere a risorse locali (pc, laptop, NAS, ecc), risorse remote (siti web, email, ftp, ecc) e dati sensibili in generale.

Requisiti e caratteristiche

La maggior parte dei sistemi operativi includono dei sistemi di autenticazione che si basano unicamente sul concetto di password o passphrase. Questo fattore di autenticazione si è rivelato debole e relativamente e semplice da aggirare.

Per superare questa limitazione utilizzeremo la Strong authentication

Strong authentication

È un metodo che combina più fattori di autenticazione:

  • Una cosa che conosco - una password, un pin, una risponda ad una domanda generica (2+2=?)
  • Una cosa che ho - un token fisico, una carta di credito, un cellulare
  • Una cosa che sono - l’impronta digitale, l’iride, DNA

In questo modo incrementeremo, in maniera sensibile, la sicurezza complessiva del sistema.

Caratteristiche

I criteri adottati per la realizzazione del sistema, sono i seguenti:

  • libertà
    • sia il software che l’hardware devono essere completamente accessibili ed aderenti alla filosofia del free software.
  • flessibilità
    • per poter integrare facilmente al sistema, applicazioni, servizi, dispositivi, ecc.
  • praticità
    • se un sistema di autenticazione risulta poco pratico, con molta probabilità, non verrà mai utilizzato.
  • costo
    • forse per proteggere un semplice servizio web, non vale la pena spendere troppi soldi.

Scelta del supporto

I dispositivi che ritengo più aderenti alle caratteristiche sopra descritte, sono sostanzialmente due:

  • YubiKey
    • diverse modalità di utilizzo
      • modalità YubiKey One-Time Password (OTP)
      • modalità OATH-HOTP
      • modalità static password (password classica + password forte generata dalla yubikey)
    • indipendente dalla piattaforma utilizzata
    • facilmente integrabile con sistemi di crittografia dati (dm-crypt, ecryptfs) e per l’autenticazione locale

  • GPF Crypo Stick
    • utilizzo dello standard OpenPGP
    • integra il chip della OpenPGP card con un lettore USB
    • supporta 3 chiavi RSA, indipendenti, a 2048 bit
    • PIN di sicurezza con lunghezza da 6 a 32 caratteri
    • supporta (con limitazioni) i certificati X.509
    • elimina l’ingombro di doversi portare sempre dietro il lettore di smartcard e la carta stessa
    • difficilmente integrabile per l’autenticazione locale

Dopo un’attenta analisi ho deciso di utilizzare la YubiKey, per via della sua flessibilità e semplicità.

Magari in un post successivo tratterò come utilizzare il dispositivo GPF Crypo Stick, per gestire un portafoglio di chiavi GPG/PGP.

Casi d’uso

autenticazione locale

Per autenticarsi alla workstation (laptop, pc, tablet) si è optato per la modalità static password in modo da poter accedere anche senza connettività e per poterla integrare facilmente con eCryptfs

Ritengo l’uso della modalità static password un buon compromesso tra livello di sicurezza e praticità. A patto che venga aggiornata mensilmente e affiancata da un buon sistema di backup (criptato) della stessa.

gestione dei dati criptati

Si è scelto uno stacked cryptographic filesystem, innanzitutto perché si vuole essere indipendenti da partizioni criptate con dimensioni fisse, e poi perché si vogliono utilizzare le stesse credenziali di accesso al sistema (password classica + yubikey static password) per montare/decifrare in modo automatico la directory con i dati da proteggere.

Per evitare rallentamenti sulle prestazioni del disco, si è optato per la cifratura di una sotto-directory della home utente (~/Private).

Questa soluzione rende più agevoli le operazioni di backup, in quanto i file in forma cifrata restano disponibili nella directory (~/.Private).

autenticazione remota

Modalità One-Time Password tramite vari client

  • connessioni ssh tramite Yubico PAM module
  • servizi internet tramite mod_authn_yubikey e ruby client
  • servizi web per la gestione di credenziali tipo passpack o lastpass (non-free!)

Modalità static password

  • chiavi ssh salvate sul file system criptato (per host in cui non è installato il modulo PAM Yubico)
  • in generale applicazioni che utilizzano file sul file system criptato per autenticarsi (certificati SSL, chiavi GPG, ecc)

Configurazione

modalità OTP (Strong authentication)

openssh

Installiamo il modulo yubico-pam, compilando i vari sorgenti o tramite il pacchetto debian:

1
2
3
sudo echo "deb http://ppa.launchpad.net/fredrikt/yubico/ubuntu lucid main" >> /etc/apt/sources.list.d/yubikey-pam.list
sudo aptitude update
sudo aptitude install libpam-yubikey

Impostiamo il modulo pam come metodo di autenticazione predefinito. In questo modo possiamo autenticarci utilizzando la password dell’utente e l’OTP della yubikey.

Modifico il file /etc/pam.d/common-auth:

1
2
3
# aggiungo prima di pam_unix la regola per pam_yubico
auth    requisite                       pam_yubico.so id=16 debug
auth    [success=1 default=ignore]      pam_unix.so nullok_secure try_first_pass

Creiamo il file in cui saranno inserite le informazioni di debug

1
2
sudo touch /var/run/pam-debug.log
sudo chmod go+w /var/run/pam-debug.log

Adesso è necessario creare un file che associa la chiave ad uno o più utenti unix. Si può creare il file, sia per utente ~/.yubico/authorized_yubikeys, che globalmente aggiungendo il parametro authfile=/etc/NOMEFILE alla direttiva di pam_yubico.so.

1
auth    requisite   pam_yubico.so id=16 authfile=/etc/yubikey_mappings

(l’ID della yubikey e l’OTP, presenti in questo post, sono falsi)

~/.yubico/authorized_yubikeys
1
2
# username:yubikey ID 1:yubikey ID 2:yubikey ID N:...
kalos:cchehkifidig

Proviamo ad autenticarci con il nuovo sistema, inserendo la password unix, subito seguita (senza spazi) dal codice OTP creato tenendo premuta la yubikey per 1 secondo.

Il file di debug dovrebbe mostrare delle righe simili:

/var/run/pam-debug.log
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
[pam_yubico.c:parse_cfg(597)] called.
[pam_yubico.c:parse_cfg(598)] flags 1 argc 2
[pam_yubico.c:parse_cfg(600)] argv[0]=id=16
[pam_yubico.c:parse_cfg(600)] argv[1]=debug
...
[pam_yubico.c:pam_sm_authenticate(650)] get user returned: kalos
[pam_yubico.c:pam_sm_authenticate(754)] conv returned 62 bytes
[pam_yubico.c:pam_sm_authenticate(772)] Skipping first 18 bytes. Length is 62, token_id set to 12 and token OTP always 32.
[pam_yubico.c:pam_sm_authenticate(779)] OTP: cchehkifidighrhhehkifidighrhrhvifidighrhrhdd ID: cchehkifidig
[pam_yubico.c:pam_sm_authenticate(789)] Extracted a probable system password entered before the OTP - setting item PAM_AUTHTOK
[pam_yubico.c:pam_sm_authenticate(805)] ykclient return value (0): Success
[pam_yubico.c:check_user_token(141)] Authorization line: kalos:cchehkifidig
[pam_yubico.c:check_user_token(145)] Matched user: kalos
[pam_yubico.c:check_user_token(149)] Authorization token: cchehkifidig
[pam_yubico.c:check_user_token(152)] Match user/token as kalos/cchehkifidig

Se tutto è andato bene rimuoviamo il file di debug ed eliminiamo la direttiva debug nel file /etc/pam.d/common-auth.

lastpass (non-free!)

Lastpass offre un sistema per gestire le password dei siti web, che integra l’utilizzo della yubikey. Un video ci mostra un esempio di utilizzo.

modalità static password

configurazione della yubikey

La moderne yubikey, supportano due diverse configurazioni, utilizzabili nello stesso dispositivo.

  • La prima viene richiamata tenendo premuta la chiave per un lasso di tempo di 0.3 - 1.5 secondi.
  • La seconda viene richiamata tenendo premuta la chiave per un lasso di tempo di 2.5 - 5 secondi.

Normalmente la chiave viene fornita con una sola configurazione attiva, impostata per l’utilizzo dell’OTP. Per utilizzare la seconda configurazione è necessario installare il programma yubikey-personalization.

1
sudo aptitude install yubikey-personalization

Inseriamo la yubikey e impostiamo la seconda configurazione per l’utilizzo della modalità static password, con il seguente comando:

1
sudo ykpersonalize -2 -ofixed=ichkicichv -o-man-update

Vediamo brevemente i vari parametri:

  • -2 serve a selezionare la seconda configurazione.

  • -ofixed serve a dare un prefisso, di massimo 16 caratteri, che identifica la chiave statica. È possibile utilizzare il convertitore modhex per convertire una stringa al formato modhex, ad esempio la stringa “pippo” in formato modhex diventa “ichkicichv”.

  • -o-man-update disabilita la funzione che permette di generare una nuova password statica casuale, tenendo premuta la yubikey per un lasso di tempo di 8 - 15 secondi.

L’output del comando sarà simile a:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Firmware version 2.2.4 Touch level 1283 Program sequence 4

Passphrase to create AES key:
Configuration data to be written to key configuration 2:

fixed: m:ichkicichv
uid: h:000000000000
key: h:45c5846e7166928f1b00d131e868d90f
acc_code: h:000000000000
ticket_flags: APPEND_CR
config_flags: STATIC_TICKET|STRONG_PW1|STRONG_PW2
extended_flags:

Commit? (y/n) [n]: y

Se non si inserisce la passphrase per creare la chiave AES, questa viene generata casualmente.

È, inoltre, possibile proteggere la scrittura della configurazione con una sorta di password, chiamata access code. Per ulteriori informazioni si può consultare la manpage del programma o il manuale tecnico

cambiare la password utente

Una volta creata la chiave statica, è necessario cambiare la password utente, con un semplice:

1
passwd

Inseriamo un password relativamente semplice, e poi teniamo premuta la yubikey per 3 secondi.

configurazione ecryptfs

Assicuriamoci di caricare il modulo ecryptfs e installiamo il programma in user-space:

1
2
sudo modprobe ecryptfs
sudo aptitude install ecryptfs-utils

La configurazione è piuttosto semplice:

1
ecryptfs-setup-private

Basta inserire la nuova password utente e verranno create le directory ~/.Private ~/Private ed ~/.ecryptfs. La mount passphrase la lasciamo generare automaticamente.

Ecco l’output:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Enter your login passphrase:
Enter your mount passphrase [leave blank to generate one]:

************************************************************************
YOU SHOULD RECORD YOUR MOUNT PASSPHRASE AND STORE IT IN A SAFE LOCATION.
  ecryptfs-unwrap-passphrase ~/.ecryptfs/wrapped-passphrase
THIS WILL BE REQUIRED IF YOU NEED TO RECOVER YOUR DATA AT A LATER TIME.
************************************************************************


Done configuring.

Testing mount/write/umount/read...
Inserted auth tok with sig [a3aba160257a7eaa] into the user session keyring
Inserted auth tok with sig [059348b89995a646] into the user session keyring
Inserted auth tok with sig [a3aba160257a7eaa] into the user session keyring
Inserted auth tok with sig [059348b89995a646] into the user session keyring
Testing succeeded.

Logout, and log back in to begin using your encrypted directory.

La configurazione predefinita di ecryptfs cifra la directory ~/.Private utilizzando la password utente per decriptare la mount passphrase. Inoltre è abilitato, in maniera predefinita, il montaggio automatico di ~/Private e la cifratura dei nomi dei file.

Adesso basta ri-autenticarsi, chiudendo prima tutte le sessioni aperte con il nostro utente. Ora si può cominciare ad inserire i file sensibili nella directory ~/Private. Questi file verranno criptati in maniera trasparente nella directory ~/.Private.

aggiornare la password

Le password vanno aggiornate con una certa frequenza, e quella statica della yubikey non fa eccezione.

Per prima cosa salviamo la password attuale e la mount passphrase, decriptata, in variabili temporanee:

1
2
read -s old_pass # inseriamo la password vecchia password (inclusa la password della yubikey)
mount_pass=$(echo $old_pass | ecryptfs-unwrap-passphrase ~/.ecryptfs/wrapped-passphrase -)

Generiamo una nuova password statica per la yubikey, magari con un nuovo prefix (pluto) :

1
sudo ykpersonalize -2 -ofixed=ichrigifhv -o-man-update

Cambiamo la password utente, utilizzando una classica password (anche quella vecchia) insieme alla nuova password generata dalla yubikey:

1
2
# utilizzo sudo per evitare di dover inserire la vecchia password
sudo passwd $USER

Cifriamo la mount passphrase con la nuova password utente:

1
2
read new_pass # inseriamo la nuova password
echo "$mount_pass\n$new_pass" | ecryptfs-wrap-passphrase ~/.ecryptfs/wrapped-passphrase

Eliminiamo le variabili:

1
unset old_pass mount_pass new_pass

backup

Se non si vuole correre il rischio di perdere le credenziali per i propri sistemi (locali e remoti) ed l’accesso ai dati sensibili, è fondamentale stabilire una buona politica di backup.

credenziali remote

La soluzione migliore è quella di possedere 2 yubikey, una per tutti i giorni ed una da conservare in un posto sicuro. Ovviamente bisogna abilitare la seconda chiave per vari servizi web di gestione password, ssh, web (mod_authn_yubikey), ecc

Un’altra soluzione, soprattutto per le credenziali ssh, è quella di aggiungere all’host, un utente con accesso limitato e con una password forte, che possa solamente decriptare un file, con un’altra password forte, che contiene la password per poter accedere allo stesso sistema come un utente privilegiato.

Una sorta di backdoor con due livelli di protezione… l’ultima cosa che vogliamo è perdere il controllo dei nostri sistemi, non è vero? ;)

credenziali locali

Per salvaguardare le password classiche e quelle generate dalla yubikey, uno dei metodi più semplici è quello di farsi mandare via email un file criptato con tutte le credenziali.

Ecco un esempio di script da eseguire ad ogni aggiornamento della password:

Le possibili soluzioni sono infinite, si può criptare il file con le credenziali utilizzando l’OTP della yubikey di scorta, criptarlo con la propria chiave GPG, steganografarla, ecc…

Insomma basta solo un po’ di fantasia.