‫-: Quindi, in precedenza,
‫abbiamo già implementato una semplice funzionalità
‫di registrazione,
‫ma in questa lezione registreremo anche
‫l'utente in un processo di registrazione più reale.
‫Quindi, a partire da questa
‫lezione, inizieremo davvero a implementare la nostra
‫autenticazione, e quindi questo diventa davvero serio.
‫E quindi, prima di iniziare,
‫voglio darti un avvertimento qui,
‫quindi l'autenticazione è molto difficile da ottenere e molti
‫tutorial là fuori che troverai quando
‫cercherai l'autenticazione con
‫come Node. js ed
‫Express, molti di questi commettono molti errori gravi
‫e semplificano eccessivamente le cose che non dovrebbero essere semplificate.
‫Va bene, questo non vuol dire che tutti
‫i tutorial
‫là fuori siano cattivi,
‫va bene, o che siano inutili o qualcosa del genere, ma
‫passo davvero settimane a ricercare tutte
‫le migliori pratiche e
‫a perfezionare e migliorare il mio codice, per rendere
‫questa sezione di autenticazione che noi comincerò
‫a implementare ora nel miglior modo possibile, per un
‫principiante come te, va bene, e questo perché dobbiamo essere
‫davvero molto attenti quando scriviamo questa parte dell'applicazione, perché ricorda, i
‫dati dei nostri utenti sono in gioco qui
‫è in gioco anche
‫la fiducia nell'azienda che gestisce
‫l'applicazione, quindi implementare l'autenticazione è una
‫vera responsabilità in cui non si dovrebbero commettere errori.
‫Ora ci sono alcune
‫biblioteche là fuori che possono aiutarci a
‫implementare l'autenticazione e l'autorizzazione e la più nota
‫si chiama Passport, ma anche
‫una biblioteca del
‫genere non ti toglie tutto il lavoro e
‫tutte le responsabilità, va bene.
‫Ora, in
‫questo caso, implementeremo l'intera
‫logica di protezione e autorizzazione dell'accesso da soli, tranne
‫ovviamente per l'implementazione del token web Jason di
‫cui abbiamo parlato nell'ultimo video stesso.
‫Ok, quindi tutte le firme e le
‫verifiche, tutta quella roba, la lasceremo alla biblioteca WJT
‫ma poi il resto, lo
‫implementeremo noi stessi nelle prossime due lezioni.
‫Ora, come ho detto
‫prima, abbiamo già la nostra funzione di registrazione qui, giusto, ma
‫in questo momento,
‫tutto ciò che fa è semplicemente creare
‫un nuovo utente e quindi inviarlo al client.
‫Ora, poco dopo aver finito di registrare questo corso,
‫ho notato
‫che c'è una falla di sicurezza
‫molto seria in questo modo di
‫iscrivere gli utenti, quindi fondamentalmente il problema
‫è che in questo momento creiamo un nuovo utente usando
‫tutti i dati che arrivano
‫con il corpo giusto, e quindi il problema qui
‫è che in questo modo, chiunque può specificare il ruolo come diritto
‫di amministratore, quindi in pratica, tutti ora possono semplicemente registrarsi come
‫amministratore nella nostra
‫applicazione, e quindi ovviamente non è necessario.
‫Quindi, ancora una volta, questo è un grave difetto
‫di sicurezza e ovviamente dovremo risolverlo e
‫risolverlo è in realtà abbastanza semplice.
‫Quindi quello che ti serve invece di questa riga
‫di codice, che è selezionata
‫qui è questo pezzo di codice che ho appena messo qui sullo schermo.
‫Va bene.
‫Quindi, di nuovo, per favore vai avanti ed elimina questa riga di
‫codice che è attualmente selezionata qui
‫e sostituiscila con il codice che ho appena inserito
‫qui sullo schermo.
‫Ora qual è in realtà la grande
‫differenza qui, beh, con
‫questo nuovo codice, in pratica permettiamo solo ai dati di cui
‫abbiamo effettivamente bisogno di essere inseriti
‫nel nuovo utente, quindi solo un nome, l'e-mail e poi le password.
‫E così ora, anche se un utente prova a inserire manualmente un
‫ruolo, non lo memorizzeremo nel nuovo utente e
‫lo stesso per altre
‫cose, come ad esempio una foto.
‫Quindi questa è la soluzione rapida e semplice per quel problema.
‫Ora
‫quello che farà è che non possiamo più registrarci come amministratore,
‫e quindi se abbiamo bisogno di aggiungere
‫un nuovo amministratore
‫al nostro sistema, possiamo semplicemente creare un nuovo utente
‫normalmente e poi andare in MongoDB
‫Compass, e fondamentalmente modifica quel ruolo lì dentro.
‫Quindi modificalo
‫manualmente da utente ad amministratore, ok.
‫Ovviamente potremmo anche definire un percorso speciale
‫per la semplice creazione
‫di amministratori, ma sarebbe un po' troppo.
‫Ok, ora andiamo avanti.
‫Nota solo che il codice nel resto del
‫video e tutti i video
‫in questo corso sarà ovviamente ancora questa vecchia versione sbagliata, va bene, ma
‫in realtà nel codice finale che
‫è nel repository GitHub, l'ho
‫già corretto e abbiamo avere il codice corretto lì dentro.
‫Ad ogni modo, di solito quando ci iscriviamo a qualsiasi applicazione
‫web, allora anche tu accedi automaticamente, giusto, e
‫quindi implementiamolo molto rapidamente qui.
‫Quindi accedi al nuovo utente,
‫non appena si è registrato, ok, e
‫ricorda dalla lezione precedente, come
‫funziona, beh, tutto ciò
‫che dobbiamo fare è
‫firmare un token web Jason
‫e poi rispedirlo all'utente , ok, ma prima di
‫tutto installiamo il pacchetto MPM che useremo per
‫tutto ciò che riguarda i token
‫web di Jason.
‫Quindi nel nostro altro terminale,
‫diciamo installazione MPM, token web Jason, quindi tutto questo insieme come
‫questo e quello dovrebbe
‫quindi installare questo pacchetto e andiamo
‫avanti e
‫diamo un'occhiata a GitHub, solo per
‫vedere la documentazione e diamo
‫fallo qui, almeno
‫per ora non abbiamo più bisogno
‫di questo qui, quindi questo ci porterà alla pagina su MPM, e così
‫vedrai quanto è popolare
‫questo pacchetto in realtà, quindi
‫ne abbiamo 2. 3 milioni di
‫download settimanali, quindi è davvero una tonnellata di
‫download e possiamo dare un'occhiata anche alla
‫documentazione qui, ma personalmente preferisco farlo su GitHub.
‫Penso che sembri molto più pulito qui,
‫e ci sono così abituato
‫a questo punto, quindi di solito lo vedo solo qui, ok.
‫Ad ogni modo, la prima funzione che
‫useremo con JWT qui è sign, okay, quindi per creare
‫sostanzialmente un nuovo token, e per questo ovviamente abbiamo
‫bisogno del payload, abbiamo bisogno
‫della chiave in modo che il segreto privato
‫che ho
‫menzionato prima è memorizzato solo sul nostro
‫server e che dobbiamo firmare
‫il token e poi possiamo passare
‫alcune opzioni e faremo tutto in
‫un secondo, voglio solo mostrare l'altra funzione che abbiamo
‫qui e che davvero abbiamo un sacco di
‫opzioni qui, per esempio la scadenza
‫in, che useremo anche per usare,
‫quindi tutte queste cose
‫e poi abbiamo la verifica.
‫Quindi abbiamo anche parlato del processo di verifica
‫e questo è fondamentalmente implementato in questa funzione, ok, quindi
‫questo è quello che useremo,
‫quando accedi a un utente, ok, e questo è davvero
‫tutto quello che c'è, quindi
‫hai tutto queste diverse opzioni qui,
‫ok, hai anche la
‫decodifica ma quella non è molto importante, ok,
‫quindi vedi che questo pacchetto include davvero solo
‫le due
‫funzionalità di cui abbiamo discusso nel video precedente.
‫Quindi firma e poi verifica, ok.
‫Quindi torniamo qui e iniziamo
‫effettivamente a utilizzare il pacchetto token web Jason.
‫Quindi importiamolo qui,
‫e di solito si chiama semplicemente
‫JWT e richiede il token web Jason.
‫Ok, quindi creiamo il nostro token qui, ok,
‫e mi piacerebbe
‫chiamarlo semplicemente in questo modo, quindi solo token, ok,
‫quindi segno di punto JWT, e ora la prima cosa è il
‫carico utile, e questo è fondamentalmente
‫un oggetto per tutti i
‫dati che memorizzeremo all'interno del token, e
‫in
‫questo caso, vogliamo davvero solo l'ID dell'utente, va bene,
‫quindi niente di pazzo qui, non molti dati
‫che non sono davvero importanti.
‫Quindi diciamo che l'ID è e poi
‫otteniamo semplicemente l'ID dal nuovo utente
‫che è stato appena creato, ok, quindi il
‫nuovo utente punti e poi ricorda che in MonogoDB, l'ID è effettivamente
‫chiamato ID di sottolineatura, va bene, e così è l'oggetto
‫che sono i dati,
‫il payload, che vogliamo inserire nel nostro JWT.
‫Successivamente, abbiamo bisogno del segreto, ok, quindi fondamentalmente
‫una stringa per
‫un segreto, d'accordo, ovviamente
‫questo è terribile, d'accordo, questo è solo una specie
‫di segnaposto perché in realtà,
‫il nostro file di configurazione è un
‫posto perfetto per memorizzare questo tipo di dati segreti, quindi proprio
‫come la password per esempio, e quindi
‫andiamo ad aggiungere e modificare qui, okay, quindi chiamiamolo JWT, segreto, e
‫ovviamente il nome che diamo qui, non ha molta importanza ma quello
‫che importa è il segreto che
‫specifichiamo
‫qui, va bene, perché usando la crittografia standard HSA 256
‫per la firma, il segreto dovrebbe essere lungo almeno trentadue caratteri, va bene, ma
‫più lungo è meglio è effettivamente ed è qui
‫che molti i tutorial là fuori falliscono,
‫alcuni di loro mettono semplicemente
‫una stringa molto corta qui, ma
‫non è di nuovo l'ideale, quindi per la
‫migliore crittografia della firma,
‫di nuovo dovresti usare almeno trentadue
‫caratteri, quindi creerò il mio segreto qui ora ma dovresti
‫davvero usarne un altro,
‫ok, per favore non usare il sa me uno
‫come sto facendo perché potrebbe diventare un
‫problema di sicurezza per la tua
‫applicazione, ok, usa sempre
‫un segreto univoco per le tue applicazioni e mai
‫lo stesso, va bene, e
‫soprattutto non quello di qualcun altro, quindi
‫sicuramente non quello che io sto scrivendo ora.
‫Quindi questo può
‫essere qualsiasi cosa, non devono essere caratteri
‫o cose strane, preferisco usare una frase
‫come questa, il mio segreto ultra
‫sicuro e ultra lungo, quindi quello che è successo
‫qui, comunque dovrebbe essere
‫lungo trentadue caratteri e quindi questo è quello che
‫useremo
‫per i miei token web Jason, ma di
‫nuovo, per favore, usane un altro, va bene.
‫Ad ogni modo, torniamo al controller di autenticazione qui e
‫ora usiamolo effettivamente.
‫Quindi ricorda che una variabile di
‫ambiente è un segreto JWT di processo punto fine punto,
‫ok.
‫Quindi, a questo punto, abbiamo il carico
‫utile e abbiamo il segreto.
‫L'intestazione del token verrà effettivamente creata automaticamente, ma
‫ora ciò
‫che possiamo anche fare è
‫trasmettere alcune opzioni e l'opzione
‫che passerò è quando il JWT dovrebbe scadere.
‫Quindi questo significa che dopo il
‫tempo che passeremo qui,
‫il token web Jason non
‫sarà più
‫valido, anche se altrimenti sarebbe verificato correttamente,
‫va bene, quindi
‫questo è fondamentalmente per disconnettere un utente
‫dopo un un certo periodo di
‫tempo semplicemente come misura di sicurezza, ok.
‫Quindi definiamo effettivamente quel tempo di scadenza anche come
‫variabile di configurazione qui,
‫quindi JWT scade in e quindi qui, ovviamente, puoi usare
‫lo stesso tempo che
‫sto mettendo.
‫Quindi possiamo usare una
‫stringa speciale come ad esempio 90D e
‫l'algoritmo di firma capirà automaticamente che questo
‫significa novanta giorni, ok, potresti anche usare dieci ore o
‫cinque minuti o tre secondi o qualcosa del genere, o semplicemente un numero
‫qualsiasi , che verranno quindi trattati
‫come millisecondi
‫ma penso che sia meglio usare semplicemente
‫novanta o qualcosa del genere D,
‫quindi in questo caso novanta giorni, va bene, e
‫così di nuovo, dopo
‫novanta giorni, il JWT non sarà più
‫valido, anche se la firma è corretta e tutto è valido.
‫Ok, di nuovo come una misura di sicurezza aggiuntiva,
‫ok,
‫quindi queste opzioni, come sempre, le abbiamo passate
‫come oggetto e poi specifichiamo la
‫scadenza tra, quindi scade tra e poi il processo punto fine
‫e poi JWT scade tra, ok, e questo qui aggiungerà quindi alcuni
‫dati aggiuntivi al payload, ma
‫ovviamente non
‫è affatto un problema.
‫Quindi abbiamo appena creato un token,
‫ora tutto ciò
‫che dobbiamo fare è inviarlo al client.
‫Quindi mettiamolo qui prima dell'utente in realtà
‫e poi è così.
‫Questo è davvero tutto ciò che dobbiamo fare
‫per accedere a un
‫nuovo utente, perché
‫in questo momento non stiamo controllando se una password
‫è corretta o se
‫l'utente esiste effettivamente nel database
‫perché
‫qui in questo caso, l'utente
‫è stato davvero appena creato e
‫quindi subito, abbiamo registrato l'utente
‫nell'applicazione inviando un token, ok, e l'uso del
‫client dovrebbe quindi in qualche modo memorizzare
‫quel token, proprio
‫come abbiamo detto prima nella lezione precedente, ok, quindi diamo un salvataggio qui,
‫e proviamolo davvero, ok, quindi diamo il mio
‫vecchio indirizzo qui, hello@jonas. io, inviamolo, e aspettiamo
‫e in effetti, ecco il nostro
‫token web Jason quindi congratulazioni, hai appena creato il tuo
‫primissimo token web Jason che dovrebbe
‫assomigliare un po' a questo, e ovviamente
‫non sarà esattamente il lo stesso,
‫perché anche il nostro segreto non è
‫lo stesso, giusto, e ora quello che voglio
‫mostrarti è il
‫debugger JWT, che ti ho
‫mostrato come screenshot in precedenza
‫nell'ultimo video.
‫Quindi andiamo avanti e copiamo
‫questo token e poi andiamo a JWT. io, ok, allora quaggiù
‫abbiamo
‫il debugger e quindi
‫eliminiamo questo qui, e mettiamo il nostro e
‫subito vedi che la nostra
‫firma non è valida, ma è
‫perché la funzione sign modifica queste
‫due proprietà qui,
‫perché abbiamo specificato una scadenza data sostanzialmente.
‫Quindi questo qui è emesso alle,
‫e questa è l'ora di scadenza, ok,
‫quindi se rimuoviamo questi due da qui, vedrai che
‫ora,
‫questa firma è effettivamente verificata,
‫ok quindi ciò che è importante notare qui, è che
‫ovviamente l'intestazione è visibile okay è
‫fondamentalmente facilmente decodificabile, e quindi tu che non
‫abbiamo specificato nulla di tutto questo, è stato
‫il pacchetto token web Jason che lo ha fatto per
‫noi, ma che qui è in realtà il payload che abbiamo
‫specificato, quindi se diamo un'occhiata
‫a questo ID, dovrebbe essere esattamente lo stesso
‫che abbiamo in postino, quindi finisce
‫con sei OF, e quindi in effetti, è esattamente
‫lo stesso giusto, ok, quindi questi due
‫qui sono aperti e quindi la firma ovviamente, non possiamo
‫vedo davvero, perché ovviamente il nostro segreto è
‫proprio questo, è davvero segreto, d'accordo, quindi questo era
‫solo per mostrarti che tutto funziona, e chiudiamo questo,
‫e sì, non siamo
‫in grado di accedere agli utenti, ma solo se l'utente si
‫è appena registrato, perché in quel
‫caso non abbiamo bisogno di verificare l'e-mail
‫nel database, e
‫nemmeno il parola d'ordine, ok.
‫Quindi fare tutto questo è un processo molto più
‫complesso, ed è quello che
‫faremo nella prossima lezione,
‫quindi in seguito, effettueremo l'accesso degli utenti, in
‫base al loro indirizzo email e alla loro password.