Integrazione dell'autenticazione a due fattori con CodeIgniter

Con la recente serie di intrusioni di alto profilo (hack) presso Sony e altre società, è tempo di dare una seconda occhiata alla sicurezza del tuo sito web. L'autenticazione a due fattori è un passo nella giusta direzione per proteggere il tuo sito web dagli aggressori. In questo tutorial, daremo un'occhiata all'implementazione di questo nella nostra applicazione CodeIgniter.

Cos'è l'autenticazione a due fattori?

L'autenticazione a due fattori richiede agli utenti di utilizzare qualcosa che conoscono, come un nome utente e una password, e qualcosa che hanno, come un telefono, per accedere.

Ultimamente, aziende come Google e Facebook hanno implementato l'autenticazione a due fattori per i loro utenti. Altri servizi, come MailChimp, utilizzano forme alternative di autenticazione a due fattori per aiutare a contrastare gli aggressori. Ma ancora, in particolare l'autenticazione a due fattori?

L'autenticazione a due fattori è un modo per dimostrare la tua identità in base al tuo nome utente e password e un dispositivo fisico che puoi portare con te.

Ciò rende molto più difficile per i criminali rubare la tua identità, dal momento che avranno bisogno di accedere al tuo telefono o token hardware - non solo le tue credenziali di accesso.

Fortunatamente per te, Duo Security offre un servizio gratuito a due fattori ideale per chiunque voglia proteggere il proprio sito web.

Duo non è solo gratuito, ma è pieno di funzionalità. Ti permettono di autenticarti in vari modi, tra cui:

• Autenticazione Phonecall
• Token basati su SMS
• Generatore di token dell'app per dispositivi mobili
• Autenticazione basata su push
• Token hardware disponibili per l'acquisto

Passaggio 1: installazione

Setup CodeIgniter

Se non hai mai lavorato con CodeIgniter, ti consiglio vivamente di dare un'occhiata alla serie Code Igniter From Scratch.

Questo tutorial si baserà sull'esercitazione Easy con il tutorial CodeIgniter. Questo tutorial ti sarà molto più facile capire se completi il ​​tutorial precedente prima di continuare. Utilizzeremo i file di quel tutorial come punto di partenza.

Si prega di verificare che il tuo config / autoload.php ha caricato i seguenti aiutanti.

$ autoload ['helper'] = array ('url', 'form');

Crea un account

Vai a Duo Security e registrati per un account.

Offrono un piano gratuito per progetti open source e per siti con meno di 10 utenti Duo (un utente Duo è qualcuno che utilizzerà l'autenticazione a due fattori per accedere).

Crea un'integrazione

Dopo la registrazione, è necessario accedere a Duo e creare un'integrazione. Una volta effettuato l'accesso, fare clic su integrazioni sul pannello laterale per visualizzare la pagina delle integrazioni. Da lì, fai clic sul pulsante "Nuova integrazione".

Assicurati che l'integrazione che crei sia un'integrazione di Web SDK. Questo ti permetterà di usare la loro API PHP con CodeIgniter.

Il nome di integrazione è utilizzato solo sul sito Web di Duo. Questo è solo un modo per identificare la tua integrazione. Duo ha una guida introduttiva che spiega come impostare un'integrazione.

Scarica il Web SDK

Oltre a configurare un'integrazione, devi scaricare il Web SDK.

Ci sono due parti dell'SDK di cui avremo bisogno: un file PHP (duo_web.php) e un file JavaScript. Si noti che JavaScript ha una dipendenza da jQuery e il JavaScript fornito in bundle viene fornito con jQuery.

Utilizzeremo il codice JavaScript in bundle, ma tieni presente che, se non lo fai, jQuery deve essere caricato prima del codice JavaScript fornito da Duo. Per ulteriori informazioni su Web SDK e come funziona, consultare la documentazione all'indirizzo http://www.duosecurity.com/docs/duoweb

Passaggio 2: modifiche per la sicurezza

Dopo aver terminato l'autenticazione Easy con il tutorial CodeIgniter, è necessario disporre di un sistema di accesso di base.

Hashing migliore

Come primo passo, aggiungeremo una forte funzione di hashing al database. Openwall ha una bella libreria di hashing PHP che implementa bcrypt. L'ultima versione di phpass è 0.3 al momento di questo articolo.

Vai avanti e scarica phpass dal loro sito web: http://openwall.com/phpass/. Dopo aver scaricato e annullato l'archiviazione della cartella, dovrai posizionarlo nella cartella delle tue librerie.

Ora dovremo creare il nostro file di libreria come interfaccia per phpass. Crea un nuovo file di libreria, denominato password.php. La nostra libreria avrà due funzioni:

• una funzione di hash per ripassare le vecchie password
• una funzione check_password per confrontare gli hash con le password in chiaro.

require_once ( 'phpass-0.3 / PasswordHash.php'); class Password var $ hasher; function __construct () // 8 è la forza dell'hash. Un valore più grande può essere utilizzato per una maggiore sicurezza. // TRUE rende le password portatili. FALSE è molto più sicuro. $ this-> hasher = new PasswordHash (8, TRUE);  function hash ($ pass) return $ this-> hasher-> HashPassword ($ pass);  function check_password ($ pass, $ hash) return $ this-> hasher-> CheckPassword ($ pass, $ hash); 

Il require_once () la dichiarazione assicura che saremo in grado di utilizzare il PasswordHash classe da phpass.

PasswordHash prende due argomenti nel suo costruttore:

• un numero che indica la forza hash
• un booleano sul fatto che le password debbano essere o meno portatili.

In questo caso, renderemo le nostre password portatili.

Ciò significa essenzialmente che l'hash non è così forte, ma se dovessimo mai cambiare server o spostare il database, possiamo fare una copia. Se non utilizziamo uno schema di hashing portatile, corriamo il rischio che tutti i nostri utenti creino nuove password se il database viene spostato.

Nota: Anche se stiamo implementando una funzione di hashing più forte, dovresti comunque richiedere agli utenti di avere una password sicura.

Modifica del modello di amministrazione

 funzione pubblica verify_user ($ email, $ password) $ q = $ this -> db -> dove ('email_address', $ email) -> limit (1) -> get ('utenti'); if ($ q-> num_rows> 0) $ result = $ q-> row (); $ This-> load-> library ( 'password'); // Assicurati che gli hash corrispondano. se ($ this-> password-> check_password ($ password, $ result-> password)) return $ result;  return false; 

In precedenza, stavamo selezionando l'utente tramite l'indirizzo email e la password con hash. Ora stiamo prelevando l'utente dal database in base all'indirizzo e-mail. Ciò significa che dobbiamo convalidare la password prima di poter restituire l'utente.

Dopo aver estratto l'utente dal database, verrà caricata la libreria delle password appena creata e verificata che la password inserita corrisponda alla password con hash.

Se le due password coincidono, procediamo a restituire l'utente, altrimenti, ritorniamo falso.

Assicurati di utilizzare la libreria delle password per creare una nuova password per te. Le password nel database non saranno valide ora!

Modifica della tabella degli utenti

Stiamo andando ad aggiungere un campo di autorizzazione di base al database. Questa autorizzazione determinerà se l'utente effettuerà o meno l'accesso con l'autenticazione a due fattori.

Abbiamo bisogno di aggiungere una colonna alla tabella utenti per le autorizzazioni a due fattori. È possibile farlo tramite phpMyAdmin o eseguendo il seguente SQL.

Utenti ALTER TABLE AGGIUNGI due_factor_permission BOOLEAN NOT NULL;

Il valore 1 nella colonna dei permessi farà sì che l'utente usi l'autenticazione a due fattori.

SQL aggiungerà una colonna booleana alla tabella degli utenti. Lo useremo per richiedere agli utenti di utilizzare l'autenticazione a due fattori o di aggirarla.

Se hai fatto bene, dovresti vedere una nuova colonna nella tabella degli utenti. Dovrai quindi aggiornare un record corrente o inserire un nuovo record che imposta two_factor_permission a vero (1).

Se questa colonna è impostata su falso (0), l'utente sarà in grado di bypassare l'autenticazione a due fattori. Questo è l'ideale per gli utenti che non hanno bisogno dello stesso livello di sicurezza di un amministratore.

Passaggio 3: utilizzo delle impostazioni di autorizzazione

Avremo bisogno di un modo per bypassare l'autenticazione secondaria, nonché un modo per inserire un passaggio di autenticazione secondario per il processo di accesso.

Bypassare l'autenticazione secondaria

Prima di tutto, avremo bisogno di un modo per aggirare l'autenticazione secondaria. Ciò significa che dovremo ispezionare l'utente nel controller di amministrazione.

 if ($ res! == FALSE) $ _SESSION ['username'] = $ res-> email_address; if ($ res-> two_factor_permission) $ this -> _ second_auth ($ res-> email_address); ritorno;  else $ _SESSION ['logged_in'] = TRUE; redirect ( 'benvenuto'); 

Questo controlla se l'utente deve accedere con il nostro sistema a due fattori.

Se l'utente deve utilizzare l'autenticazione a due fattori, vogliamo che vadano alla pagina di autenticazione secondaria senza registrarli.

Invece di reindirizzare l'utente, possiamo chiamare il _second_auth () funzione e hanno che caricare la pagina. Il "ritorno"l'istruzione evita di caricare il modulo di accesso.

Abbiamo creato una nuova variabile di sessione connesso che utilizzeremo per verificare che l'utente abbia effettuato l'accesso. Ciò significa che dobbiamo apportare alcune modifiche ai reindirizzamenti.

Risolvere i reindirizzamenti

Ci sono due reindirizzamenti che devono essere modificati: il primo è nella funzione di indice del controller admin.

if (isset ($ _ SESSION ['logged_in']) && $ _SESSION ['logged_in'] === TRUE) redirect ('welcome'); 

L'altro è nel benvenuto controller. Dobbiamo assicurarci che l'utente non abbia effettuato l'accesso prima di reindirizzare.

if (! isset ($ _ SESSION ['logged_in']) || $ _SESSION ['logged_in']! == TRUE) reindirizzamento ('admin'); 

Inserimento dell'autenticazione secondaria

Ora dobbiamo gestire l'autenticazione secondaria.

Nel admin / index funzione, chiamiamo _second_auth (), quindi scriviamo una funzione di base.

 public function _second_auth ($ username) echo "Welcome $ username, stai guardando una pagina di autenticazione secondaria."; 

Step 4: Costruire la vista

I sistemi di autenticazione tradizionali considerano gli accessi come un processo a fasi singole.

Duo ci fornisce un po 'di JavaScript e HTML per l'iniezione tra i due passaggi. Questo significa che avremo bisogno di creare una vista con il codice richiesto.

Creiamo una nuova vista, chiamata second_auth.php nel visualizzazioni cartella. Dovremo inserire l'iframe e il codice JavaScript forniti da Duo per farlo funzionare.

Dovresti creare una pagina con la struttura HTML di base. Il seguente può essere inserito nel corpo:

In una configurazione tipica, manterrai tutto il tuo JavaScript in una cartella di risorse. Qui, abbiamo messo un risorse cartella nella radice del nostro sito, con un 'js'sottocartella che contiene il file JavaScript Web SDK.

Nostro src sarà simile a:

src ="Risorse / js / Duo-Web-v1.js"

Abbiamo anche bisogno di aggiungere questo secondo bit di JavaScript.

Genereremo questi dati dal controller a breve.

Inserimento di un modulo

Se hai seguito il tutorial precedente, dovresti configurare CodeIgniter per la protezione da CSRF.

Poiché JavaScript invierà i dati al nostro controller, CodeIgniter cercherà il token CSRF. Se non abbiamo questo token, avremo un errore.

Il codice JavaScript che stiamo utilizzando invierà un modulo con l'ID "duo_form". Tutto ciò che dobbiamo fare è crearlo.

echo form_open ('admin', array ('id' => "duo_form")); echo form_close ();

Usando la classe del modulo, CodeIgniter inserisce automaticamente il token. Quando il modulo viene pubblicato, CodeIgniter troverà il token e continuiamo.

Passaggio 5: preparazione dei dati

Indietro nel Admin controller, abbiamo bisogno di generare alcuni dati nel nostro _second_auth () funzione.

L'host è l'URL dell'API che ti è stato fornito quando ti sei registrato con Duo. Questo URL dovrebbe assomigliare a qualcosa api-xxxxxxxx.duosecurity.com (dove 'xxxxxxxx' è una stringa univoca legata al tuo account Duo).

$ data ['host'] = "api-xxxxxxxx.duosecurity.com";

Ricorda di sostituire l'host con il tuo URL specifico. L'URL sopra non funzionerà.

L'azione successiva è l'URL che gestirà la risposta una volta che l'utente ha tentato di autenticarsi con Duo.

Creeremo un'altra funzione nel controller di amministrazione per gestire il post-back. Per ora, nomineremo la funzione process_second_auth ().

 $ data ['post_action'] = base_URL (). "Admin / process_second_auth";

Caricamento di PHP Web SDK

Assicurati di rinominare "duo_web.php" in "duo.php" per evitare errori CodeIgniter.

Se non hai scaricato l'ultima copia di duo_web.php, puoi scaricarlo dalla pagina GitHub di Web SDK di Duo.

Poiché il Web SDK si presenta come una classe PHP, possiamo rinominarlo in "duo.php"e inseriscilo nella nostra cartella" application / library ".

Dopo aver inserito il file nel librerie cartella, possiamo caricarlo nel nostro controller.

 public function _second_auth ($ username) $ this-> load-> library ('duo'); $ data ['host'] = "api-xxxxxxxx.duosecurity.com"; $ data ['post_action'] = base_URL (). "Admin / process_second_auth"; echo "Welcome $ username, stai guardando una pagina di autenticazione secondaria."; 

Generazione della richiesta firmata

Per capire come generare sig_request, devi capire cosa stiamo generando.

Il $ Akey la variabile deve essere lunga almeno 40 caratteri, altrimenti la libreria Duo restituirà un errore!

Duo Web SDK crea due token firmati, uno con la chiave segreta che ti danno, un altro con una chiave dell'applicazione che tu componi.

sig_request è una combinazione dei due token.

Creando la tua chiave di applicazione avrai un secondo livello di sicurezza. Un utente malintenzionato avrà bisogno sia della chiave segreta di Duo che della chiave dell'applicazione personale per falsificare un token.

Ora genereremo il 'sig_request'. Duo ti fornirà una chiave di integrazione e una chiave segreta quando crei un'integrazione.

Assicurati di sostituire il testo sottostante con la chiave di integrazione e la chiave segreta che ti è stata data. Devi creare la tua chiave segreta. Deve essere lungo almeno 40 caratteri e dovrebbe essere il più casuale possibile.

public function _second_auth ($ username) $ this-> load-> library ('duo'); // Duo Integration Key $ ikey = "SOSTITUISCI LA TUA CHIAVE DI INTEGRAZIONE DUO"; // Duo Secret Key $ skey = "SOSTITUISCI CON TE DUO SECRET KEY"; // Chiave applicazione personale $ akey = "CREA UN TASTO DELL'APPLICAZIONE"; $ data ['host'] = "api-xxxxxxxx.duosecurity.com"; $ data ['post_action'] = base_URL (). "Admin / process_second_auth"; $ data ['sig_request'] = $ this-> duo-> signRequest ($ ikey, $ skey, $ akey, $ username); echo "Welcome $ username, stai guardando una pagina di autenticazione secondaria."; 

Duo signRequest () genererà i token e li restituirà come stringa da passare a sig_request.

Ora abbiamo bisogno di caricare i dati nella vista che abbiamo creato in precedenza.

public function _second_auth ($ username) $ this-> load-> library ('duo'); // Duo Integration Key $ ikey = "SOSTITUISCI LA TUA CHIAVE DI INTEGRAZIONE DUO"; // Chiave segreta Duo $ skey = "SOSTITUISCI IL TUO TASTO SEGRETO DUO"; // Chiave applicazione personale $ akey = "CREA UN TASTO DELL'APPLICAZIONE"; $ data ['host'] = "api-xxxxxxxx.duosecurity.com"; $ data ['post_action'] = base_URL (). "Admin / process_second_auth"; $ data ['sig_request'] = $ this-> duo-> signRequest ($ ikey, $ skey, $ akey, $ username); $ this-> load-> view ('second_auth', $ data); 

Se tenti di accedere ora, dovresti vedere questa pagina:

Questo è il modulo di iscrizione. Puoi registrare il tuo cellulare qui, ma non abbiamo nulla per elaborare l'autenticazione secondaria in modo che non possa accedere.

Se non si vede nulla, visualizzare l'origine della pagina per i messaggi di errore. Eventuali errori con i dati verranno visualizzati nel > etichetta.

public function process_second_auth () if (isset ($ _ SESSION ['logged_in']) && $ _SESSION ['logged_in'] === TRUE) redirect ('welcome'); 

$ This-> load-> library ( 'duo'); // Stesse chiavi utilizzate in _second_auth () $ ikey = "SOSTITUISCI LA TUA CHIAVE DI INTEGRAZIONE DUO"; $ skey = "SOSTITUISCI IL TUO TASTO SEGRETO DUO"; $ akey = "SOSTITUISCI LA TUA CHIAVE DELL'APPLICAZIONE";

$ sig_response = $ this-> input-> post ('sig_response'); $ username = $ this-> duo-> verifyResponse ($ ikey, $ skey, $ akey, $ sig_response);

if ($ username) $ _SESSION ['logged_in'] = TRUE; redirect ( 'benvenuto');  else redirect ('admin'); 

public function process_second_auth () if (isset ($ _ SESSION ['logged_in']) && $ _SESSION ['logged_in'] === TRUE) redirect ('welcome');  $ this-> load-> library ('duo'); // Le stesse chiavi utilizzate in _second_auth () $ ikey = "SOSTITUISCI LA CHIAVE DI INTEGRAZIONE DI DUO"; $ skey = "SOSTITUISCI IL TASTO SEGRETO DI DUO"; $ akey = "SOSTITUISCI LA TUA CHIAVE DELL'APPLICAZIONE"; $ sig_response = $ this-> input-> post ('sig_response'); $ username = $ this-> duo-> verifyResponse ($ ikey, $ skey, $ akey, $ sig_response); if ($ username) $ _SESSION ['logged_in'] = TRUE; redirect ( 'benvenuto');  else redirect ('admin');