Consolidarea mai multor surse de identitate cu Auth0

Prezentare generala

De-a lungul acestui articol, vom vedea cum un imens producator de carduri grafice a profitat de Auth0 pentru a consolida identitatile utilizatorilor din mai multe aplicatii. Inainte de a se baza pe Auth0, fiecare aplicatie gazduita de producator avea propriul management al identitatii. Adica, daca John Doe ar avea acces la mai multe aplicatii, ar trebui sa administreze (si sa-si aminteasca) doua sau mai multe date de acreditare. Desigur, el ar putea avea aceeasi combinatie de e-mail si parola pentru toate aplicatiile. Dar daca, din orice motiv, ar trebui sa schimbe parola pentru una dintre ele, celelalte conturi ale sale nu ar fi afectate. In plus, orice date cu caracter personal, cum ar fi adresa, ar trebui sa fie actualizate manual pe fiecare aplicatie.

Acest tip de scenariu, desi este comun, nu este bun pentru utilizatorul final sau proprietarul aplicatiilor. Daca producatorul dorea sa implementeze o noua caracteristica de securitate, ar trebui sa refacteze mai multe aplicatii. Chiar mai mult, daca ar dori sa comunice cu utilizatorii lor, nu ar avea o singura sursa de adevar care sa arate cati utilizatori distinsi au sau detaliile personale ale acesteia (intrucat ar putea fi depasit intr-o singura aplicatie si actualizate pe un alt).

Din fericire pentru producator si pentru companii care se confrunta cu scenarii similare, Auth0 faciliteaza consolidarea identitatilor in situatii de genul acesta.

Crearea mai multor surse de identitati

Pentru a simula scenariul producatorului, vom folosi doua aplicatii Node.js care depind de baze de date diferite. Exista unii utilizatori cu aceleasi credentiale (e-mail si parola) pe fiecare aplicatie si unii utilizatori care exista doar pe o aplicatie sau pe cealalta. Cand un utilizator exista pentru ambele aplicatii, unele detalii ale datelor sale personale vor diferi pentru un cont si altul. Aceste diferente au fost create pentru a arata cum fuzionarea profilurilor din diferite aplicatii este usoara cu Auth0.

Pentru a urmari acest articol si pentru a vedea consolidarea profilului in practica, va trebui doar sa va inscrieti pentru un cont Auth0 gratuit si sa configurati cateva setari pe acesta. Acest cont Auth0 va comunica apoi cu ambele aplicatii, gazduite aici si aici, pentru a efectua urmatorii pasi:

• Verificati, in timpul conectarii, daca o acreditare este valabila sau nu.
• Verificati, in timpul unei preluari de parole sau a unei inscrieri, daca exista o adresa de e-mail pe una dintre aplicatii.

Verificarea credentiala si procesele de verificare prin e-mail au loc prin solicitarile facute de Auth0 catre ambele aplicatii. Aceste solicitari sunt emise de doua scripturi de actiune ale bazei de date Auth0 pe care le vom configura in contul nostru. In ambele cazuri, daca utilizatorul exista si contine profiluri pe ambele aplicatii, aceste profiluri sunt contopite si salvate pe Auth0. Daca utilizatorul nu exista decat pe una dintre aplicatii, se foloseste acest profil unic.

Note de securitate

Deoarece ambele aplicatii trebuie sa expuna punctele finale pe care Auth0 le va consuma, trebuie sa securizam aceste puncte pentru a evita atacurile din surse necunoscute. La Auth0 favorizam standardele, de aceea vom asigura aplicatiile noastre cu ajutorul OAuth 2.0. Vom folosi subventia Client Credentials, pe care o utilizeaza interfetele masina-masina pentru a comunica.

Cu Grantul de acreditare a clientilor (definit in RFC6749, sectiunea 4.4), un Client non-interactiv (un CLI, un daemon sau un serviciu care ruleaza in backend) poate solicita direct Auth0 un access_token utilizand acreditarile clientului (id-ul clientului si secretul clientului) a autentifica. In acest caz, token-ul reprezinta in sine Clientul Non Interactive, in loc de un utilizator final.

In scenariul nostru, scripturile de actiune ale bazei de date Auth0 pe care le vom crea vor prelua un access_token din Auth0, apoi vor folosi acest simbol pentru a se identifica pe ambele aplicatii. Aceste aplicatii au fost securizate anterior cu un software de mijloc Express care valideaza JSON Web Tokens (JWTs) generate de Auth0 cu urmatoarele caracteristici:

• audienta: „http: // sample-app /”
• emitent: „https://bkrebs.auth0.com/”
• algoritmi: [‘RS256’]

Intrucat aplicatiile asteapta JWT-uri cu emitentul https://bkrebs.auth0.com/, vom folosi un client_id si un client_secret configurat anterior pe contul meu Auth0 (bkrebs). De dragul minutiunii, vom recrea aceste proprietati pentru a intelege procesul, dar nu le vom folosi.

Consolidarea mai multor identitati cu Auth0

Dupa crearea contului nostru pe Auth0 sau reutilizarea unuia existent, primul pas este crearea unei conexiuni la baze de date. Sa incepem vizitand pagina Conexiuni de baze de date din tabloul de bord de gestiune, unde vom face clic pe butonul Creare conexiune DB. In forma care ne este aratata, vom defini pur si simplu un nume pentru conexiune, consolidarea profilului si vom apasa pe butonul Creare.

Dupa aceea vom fi redirectionat catre pagina de setari a noii conexiuni. Auth0 ne permite sa stocam si sa gestionam in siguranta datele de acreditare (e-mail si parola), fie intr-o baza de date Auth0, fie in propria noastra baza de date personalizata. Cum avem deja doua baze de date, vom merge la fila Baza de date personalizata si vom activa comutatorul „Utilizati propria mea baza de date”.

Activarea acestei optiuni va face aceasta conexiune dependenta de bazele noastre de date personalizate pentru totdeauna, deoarece va interactiona intotdeauna cu ele atunci cand utilizatorii incearca sa se autentifice, sa se inscrie, sa schimbe parola si asa mai departe. Acest lucru nu este exact ceea ce ne dorim. Scopul nostru este sa folosim Auth0 pentru a imbina utilizatorii din mai multe aplicatii intr-o baza de date fiabila si sigura. Prin urmare, vom reveni la fila Setari si vom activa optiunea „Importati utilizatorii in Auth0”. Aceasta optiune, asa cum este explicat in pagina Setari, este utilizata atunci cand dorim sa migram treptat utilizatorii catre magazinul de utilizatori Auth0.

Acum, daca ne intoarcem la fila Baze de date personalizate, vom vedea ca nu mai are cinci scripturi de actiune a bazei de date (asa cum se arata in imaginea de mai sus). Primim doua scripturi numai dupa ce am activat optiunea de a migra utilizatorii.

Primul script, numit Logare, este utilizat pentru autentificarea unui utilizator impotriva credentialelor stocate in bazele noastre de date. Scriptul de conectare este executat atat atunci cand un utilizator incearca sa se autentifice sau imediat dupa inregistrare (ca o verificare a faptului ca utilizatorul a fost inscris cu succes).

Al doilea script, numit Get User, este folosit pentru a prelua un profil de utilizator din baza de date existenta, fara a autentifica utilizatorul. Acest script este utilizat pentru a verifica daca un utilizator exista inainte de a executa fluxuri care nu necesita autentificare (cum ar fi inregistrarea si resetarea parolei).

In curand, vom aborda implementarea ambelor scripturi, dar mai intai sa cream reprezentarea API a aplicatiilor noastre si a unui Client pentru a le asigura in mod corespunzator impotriva solicitarilor necunoscute.

Crearea unei API Auth0

Asa cum se explica in documentatia Auth0, o API este o entitate care reprezinta o resursa externa, capabila sa accepte si sa raspunda solicitarilor de resurse protejate facute de clienti. Aceasta definitie se potriveste perfect pentru ambele aplicatii care contin utilizatorii pe care dorim sa le unim si sa le importam in contul nostru Auth0. Prin urmare, avem nevoie de o API care sa reprezinte aceste aplicatii pentru a le asigura in mod corespunzator impotriva solicitarilor neautentificate.

Pentru a crea o API, sa ne indreptam catre pagina API din tabloul de bord al managementului Auth0 si sa facem clic pe butonul „Creare API”. Astfel va aparea un formular cu trei campuri: nume, identificator si algoritm de semnare.

Numele este doar un identificator prietenos care ne ajuta sa ne amintim ce reprezinta aceasta API. Deoarece aceasta API va reprezenta Furnizorii de identitate mostenire pe care ii avem, haideti sa ii dam un nume precum „Legacy IdP”. Nu vom avea nevoie de acest nume in alta parte, dar este bine sa dam un nume usor de retinut pentru a mentine lucrurile in ordine.

Identificatorul este o setare importanta care este folosita atat la solicitarea unui acces_token, cat si la validarea acestor jetoane. Aceasta proprietate este cunoscuta si sub denumirea de audienta si, de fiecare data cand se face o solicitare la un punct final protejat, trebuie verificata in raport cu audienta configurata in aplicatie.

In fisierul index.js care contine codul care ruleaza pe ambele aplicatii, putem vedea ca aplicatia Node.js / Express este setata sa accepte doar jetoane care vizeaza audienta legacy-idp. Prin urmare, sa setam proprietatea identificatorului noii noastre API la legacy-idp.

// … const jwtCheck = jwt ({secret: jwks.expressJwtSecret ({cache: true, rateLimit: true, jwksRequestsPerMinute: 5, jwksUri: “https://bkrebs.auth0.com/.well-known/jwks). json “}), audienta: ‘legacy-idp’, emitent:„ https://bkrebs.auth0.com/ “, algoritmi: [‘RS256’]}); // …

Ultima proprietate pe care trebuie sa o setam este „Algoritmul de semnare”. Exista doua optiuni pentru a completa aceasta proprietate: RS256 si HS256. Cel mai bun si cel mai sigur algoritm de utilizat este RS256, deoarece este un algoritm asimetric care utilizeaza cheie publica / privata. Prin urmare, sa utilizam RS256 ca algoritm de semnare.

Dupa completarea formularului cu valorile de mai sus, putem face clic pe butonul „Creare” pentru a persista noua noastra API.

Definirea scopurilor OAuth 2.0 pe API-urile Auth0

OAuth 2.0 recomanda clientilor sa specifice ce scopuri doresc sa aiba atunci cand sunt interesati sa comunice cu o API. Scopurile, pe OAuth 2.0, reprezinta permisiunile pe care clientii le au atunci cand se ocupa de resurse pe care nu le detin. De exemplu, in scenariul nostru cream o API care reprezinta doi furnizori de identitate mostenire. Deoarece nu dorim ca clientul pe care il vom crea sa aiba acces nelimitat la aceste aplicatii, putem restrictiona accesul acestuia setand ce scopuri va primi clientul in simbol. Pentru a face acest lucru, sa ne indreptam catre fila „Scopuri” a noului nostru API si adaugam doua scopuri:

• Numele domeniului de aplicare: autentificare: app1; Descrierea domeniului de aplicare: “Auth on Legacy IdP1”
• Numele domeniului de aplicare: autentificare: app2; Descrierea domeniului de aplicare: “Auth on Legacy IdP2”

Definirea scopurilor de genul acesta nu ar fi suficient. De asemenea, ar trebui sa restrictionam accesul in backend. Din fericire, acest lucru a fost deja ingrijit, asa cum putem vedea in fisierul index.js al IDP-urilor noastre mostenite:

// … app.use ((req, res, urmator) => {let requireScope = null; if (process.env.app === ‘node-1’) {Obligatoriu Scope = “authenticate: app1”;} else {obligatoriuScope = “authenticate: app2”;} if (! req.user ||! req.user.scope ||! req.user.scope.indexOf (necesarScope) <0) {res.sendStatus (401); retur ; } Urmator →(); }); // …

Crearea unui client Auth0

Pe langa API-ul pentru a reprezenta furnizorul de identitate mostenitoare, va trebui sa cream si un Client care sa reprezinte scripturile de actiune ale bazei de date Auth0 care sa comunice cu aplicatiile noastre. Sa ne indreptam catre pagina Client din tabloul de bord de gestionare Auth0 si sa facem clic pe butonul „Creare client”.

Daca faceti clic pe aceasta, va aparea un formular care solicita doua tipuri de informatii. Primul este numele clientului pe care il cream. Acest nume nu va fi atat de important, deoarece exista doar pentru a ne ajuta sa ne amintim pentru ce este folosit clientul. Asadar, sa dam un nume precum „Legacy IdP Action Script”.

A doua informatie solicitata de formular este tipul de client. Exista patru tipuri disponibile:

• Nativ: Folosim acest tip atunci cand dorim sa cream un client pentru a reprezenta o aplicatie mobila sau desktop care ruleaza nativ pe un dispozitiv.
• Aplicatia Web pentru o singura pagina: Folosim acest tip atunci cand dorim sa cream un client care sa reprezinte un SPA scris cu o biblioteca JavaScript (de ex. React, Angular sau Ember).
• Aplicatie Web obisnuita: Folosim acest tip atunci cand dorim sa cream un client care sa reprezinte aplicatii web vechi-scolare (cele care reimprospateaza intreaga pagina cand utilizatorul face clic pe un link sau buton).
• Clienti non-interactivi: Folosim acest tip atunci cand dorim sa cream un client care reprezinta o aplicatie CLI (Command Line Interface) sau un serviciu care ruleaza in fundal.

Avand in vedere ca scripturile de actiune ale bazei de date vor fi rulate automat atunci cand utilizatorii incearca sa autentifice sau sa recupereze parolele, cea mai buna categorie pentru clientul pe care il cream este „Clienti non-interactivi”. Dupa alegerea tipului de client putem face clic pe butonul „Creare”.

Facand clic pe acest buton ne va redirectiona catre fila „Pornire rapida” a clientului nou creat. Pe aceasta pagina putem alege API-ul pe care l-am creat in sectiunea anterioara, „Legacy IdP”. Deoarece nu am configurat API-ul pentru a accepta conexiuni de la acest nou client, tabloul de bord ne va avertiza ca trebuie sa navigam catre API pentru a autoriza clientul. Sa facem clic pe acest buton si sa facem doua lucruri:

1. Sa activam comutatorul pentru clientul „Legacy IdP Action Script” din pagina afisata.
2. Sa activam ambele scopuri create anterior (autentificare: app1 si autentificare: app2) in acest client.

Fuzionarea profilurilor la autentificare

Acum ca avem atat API-ul cat si clientul creat corect, putem configura script-ul de conectare in conexiunea noastra la baza de date. Pentru a face acest lucru, sa accesam fila „Baza de date personalizata” din conexiunea bazei de date pe care am creat-o inainte (pe care am numit-o consolidare a profilului) In aceasta fila vom inlocui codul sursa implicit cu urmatoarele:

autentificare functie (email, parola, callback) {“use strict”; const request = impune (‘[email protected]’); const Promise = impune (‘[email protected]’); const authenticate = Promise.coroutine (functie * () {const getTokenOptions = {metoda: ‘POST’, url: ‘https://bkrebs.auth0.com/oauth/token’, anteturi: {‘tipul de continut’: ‘ application / json ‘}, body:’ {“client_id”: “BvEdrxK2T2f36Hnttintbe4yIEjUC5P2”, “client_secret”: “13rf3mN0ciOEckabpE4TF4LYstBfOa19DYUBED7-MMzEM-CjR2ig” “” “” “” “” “” “” “” “” “” “” “” “” “” “” “” “” “” ” ; // primeste un token de acces pentru a comunica cu resursele de identitate mostenitoare const tokenResponse = cerere de randament (getTokenOptions); const accessToken = JSON. parse (tokenResponse) .access_token; // primeste profilul utilizatorului din ambele aplicatii let profileApp1 = {}; permiteti profilulApp2 = {}; incercati {profileApp1 = JSON.parse (randament legacyAuth (accessToken, ‘https://node-app-1.now.sh/users/authenticate’)); } catch (e) {} try {profileApp2 = JSON.parse (randament legacyAuth (accessToken, ‘https://node-app-2.now.sh/users/authenticate’)); } catch (e) {} // elimina proprietati nule din ambele profiluri pentru a face imbinarea (atribuirea) nestiind de ele Object.keys (profileApp1) .forEach ((key) => (profileApp1 [key] === null) && delete profileApp1 [tasta]); Object.keys (profileApp2) .forEach ((key) => (profileApp2 [key] === null) && delete profileApp2 [key]); // imbina ambele profiluri const profile = Object.assign ({}, profileApp1, profileApp2, {email}); returnare apel invers (nul, profil); }); autentifica(). catch (functia (e) {return return callback (noua eroare (e));}); function legacyAuth (accessToken, url) {const options = {metoda: ‘POST’, url: url, anteturi: {‘Autorizare’: ‘Portator’ + accessToken, ‘content-type’: ‘application / json’}, corp: ‘{“email”: “‘ + email + ‘”, “parola”: “‘ + parola + ‘”}’}; cerere de returnare (optiuni); }}

Pentru a intelege mai bine ce face codul de mai sus, haideti sa il impartim in bucati mai mici si sa inspectam fiecare parte. Primul lucru pe care il facem in scriptul de mai sus este sa necesita doua biblioteci: request-promisiune si bluebird. Biblioteca de solicitare-promisiune este utilizata pentru a trimite solicitari HTTP furnizorilor de identitate mostenire. Cea de-a doua biblioteca, bluebird, este folosita pentru a ne permite sa facem promisiuni, ceea ce face ca codul nostru sa fie mai putin verbos.

const request = impune (‘[email protected]’); const Promise = impune (‘[email protected]’);

Dupa necesitarea ambelor biblioteci, urmatorul pas este sa folositi bluebird pentru a crea o functie care sa se ocupe atat de procesele de autentificare cat si de imbinare a profilului. Imediat dupa definirea functiei, o declansam si definim un callback care va fi executat atunci cand apare orice eroare. Aceste erori sunt surprinse si utilizate pentru a pune capat intregului proces de autentificare.

const authenticate = Promise.coroutine (functia * () {// …}); authenticate (). catch (functia (e) {return return callback (noua eroare (e));});

In cadrul functiei de autentificare, primul lucru pe care il facem este sa trimitem o solicitare catre Auth0 pentru a obtine un acces_token. Vom folosi acest simbol pentru autentificarea scripturilor de actiune a bazei de date atunci cand emitem cereri catre furnizorii de identitate mostenire.

const getTokenOptions = {metoda: ‘POST’, url: ‘https://bkrebs.auth0.com/oauth/token’, anteturi: {‘content-type’: ‘application / json’}, body: ‘{“client_id “:” BvEdrxK2T2f36Hnttintbe4yIEjUC5P2 “,” client_secret “:” 13rf3mN0ciOEckabpE4TF4LYstBfOa19DYUBED7-MMzEM-CjR2ig_kifTfyy3Hoh “,” audience “:” legatura “; // primeste un token de acces pentru a comunica cu resursele de identitate mostenitoare const tokenResponse = cerere de randament (getTokenOptions); const accessToken = JSON.parse (tokenResponse) .access_token;

Cu accesul_token la indemana, incercam sa autentificam utilizatorul pe ambele aplicatii. Deoarece utilizatorii pot avea un profil pe o aplicatie, dar nu pe cealalta, amandoi apelam in blocuri de incercare-captura distincte. Daca autentificarea reuseste, unul dintre obiectele de profil este inlocuit. Daca nu reuseste, obiectul de profil ramane neatins (adica {}).

permiteti profilulApp1 = {}; permiteti profilulApp2 = {}; incercati {profileApp1 = JSON.parse (randament legacyAuth (accessToken, ‘https://node-app-1.

porno in tren http://livesmart.org/__media__/js/netsoltrademark.php?d=adult66.net/
filme porno free http://duxtranet.com/__media__/js/netsoltrademark.php?d=adult66.net/
rapunzel porno http://unlistednewyork.info/__media__/js/netsoltrademark.php?d=adult66.net/
filme porno traduse in romaneste http://cosmenature.com/__media__/js/netsoltrademark.php?d=adult66.net/filme-porno/amatori
porno scufita rosie http://paolaisnardi.com/__media__/js/netsoltrademark.php?d=adult66.net/filme-porno/anal
porno brasil http://wholesalecondensers.net/__media__/js/netsoltrademark.php?d=adult66.net/filme-porno/asiatice
türkçe porno http://mtfonlinelearning.com/__media__/js/netsoltrademark.php?d=adult66.net/filme-porno/beeg
virgin porno http://imap.aandbengsvs.net/__media__/js/netsoltrademark.php?d=adult66.net/filme-porno/blonde
porno cu maicute http://teresanelson.com/__media__/js/netsoltrademark.php?d=adult66.net/filme-porno/brazzers
porno private http://oldroadtests.com/__media__/js/netsoltrademark.php?d=adult66.net/filme-porno/brunete
jenifer lopez porno http://theexpress.org/__media__/js/netsoltrademark.php?d=adult66.net/filme-porno/chaturbate
porno videok magyarul http://ragingllama.net/__media__/js/netsoltrademark.php?d=adult66.net/blowjob-cu-o-studenta-la-drept-filmata-si-fututa
porno matre http://alarmsystem.co/__media__/js/netsoltrademark.php?d=adult66.net/scene-de-sex-salbatic-cu-un-cuplu-de-amatori-postat-pe-net
filme porno cu sensual jane http://randymuller.com/__media__/js/netsoltrademark.php?d=adult66.net/o-gagica-hot-se-joaca-senzual-cu-corpul-ei-in-fata-colegilor
porno cehia http://arnoldlau.com/__media__/js/netsoltrademark.php?d=adult66.net/bunaciune-se-masturbeaza-in-masina-cu-un-vibrator
porno cu curve http://www.mypetworld.biz/__media__/js/netsoltrademark.php?d=adult66.net/pustoaica-blonda-rapita-si-violata-de-mai-multi
www porno xxx http://sarahdloucks.com/__media__/js/netsoltrademark.php?d=adult66.net/minora-ejaculata-pe-fata-de-partenerul-de-sex
porno in somn http://setifersystems.com/__media__/js/netsoltrademark.php?d=adult66.net/futai-salbatic-in-toate-pozitiile-cu-un-cuplu-de-amatori
descarca porno http://themonadgroup.com/__media__/js/netsoltrademark.php?d=adult66.net/tanara-frumoasa-e-fututa-intre-tate-si-in-gura-de-prietenul-ei
film porno italiani http://anaagroup.com/__media__/js/netsoltrademark.php?d=adult66.net/nevasta-blonda-e-fututa-de-un-tanar-pe-canapeaua-din-sufragerie

now.sh/users/authenticate’)); } catch (e) {} try {profileApp2 = JSON.parse (randament legacyAuth (accessToken, ‘https://node-app-2.now.sh/users/authenticate’)); } prinde (e) {}

Dupa preluarea profilului (profilurilor) de la furnizorii de identitate, eliminam orice obiecte nule din obiecte si le imbinam intr-un singur obiect de profil care este returnat la Auth0.

// elimina proprietati nule din ambele profiluri pentru a face ca imbinarea (atribuirea) sa nu le cunoasca Object.keys (profileApp1) .forEach ((key) => (profileApp1 [key] === null) && delete profileApp1 [key]); Object.keys (profileApp2) .forEach ((key) => (profileApp2 [key] === null) && delete profileApp2 [key]); // imbina ambele profiluri const profile = Object.assign ({}, profileApp1, profileApp2, {email}); returnare apel invers (nul, profil);

Ultima bucata de cod definita in scripturile de actiune a bazei de date este functia legacyAuth. Aceasta functie este utilizata pentru a obtine profiluri de utilizator. Isi atinge obiectivul prin asamblarea si emiterea unei solicitari POST care poarta access_token in antetul Autorizatiei cu e-mailul utilizatorului si parola de pe corpul de solicitare.

function legacyAuth (accessToken, url) {const options = {metoda: ‘POST’, url: url, anteturi: {‘Autorizare’: ‘Portator’ + accessToken, ‘content-type’: ‘application / json’}, corp: ‘{“email”: “‘ + email + ‘”, “parola”: “‘ + parola + ‘”}’}; cerere de returnare (optiuni); }

Testarea procesului de autentificare

Acum ca avem toate piesele impreuna in scriptul de conectare, il putem salva si apoi testam pentru a vedea procesul de fuziune in actiune. Asa cum am explicat anterior, aplicatiile de proba sunt populate cu doua seturi diferite de utilizatori. Prima aplicatie este completata cu urmatorii utilizatori:

Parola de email Nume Prenume Adresa Oras [email protected] 123456 Bruno New York [email protected] 123456 Serena Williams New York

Iar cel de-al doilea contine urmatorii utilizatori:

Parola Parola Nume Prenume Adresa Oras [email protected] 123456 Bruno Krebs 5th Avenue [email protected] 123456 Venus Williams New York

Retineti ca utilizatorul identificat cu e-mail [email protected] exista in ambele aplicatii. Desi este prezent pe ambele aplicatii, prima nu cunoaste numele de familie sau adresa utilizatorului. A doua aplicatie cunoaste numele de familie si adresa, dar nu orasul. Prin urmare, daca il utilizam pe acest utilizator atunci cand testam scriptul de autentificare, vom termina cu un profil care contine toate proprietatile (prenume, adresa si oras).

Pentru a verifica daca obtinem acest lucru, haideti:

• Accesati pagina Conexiuni de baze de date.
• Faceti clic pe butonul Incercati (ultimul buton, etichetat cu o pictograma de redare) a bazei de date de consolidare a profilului.
• Completati formularul cu [email protected] in campul de e-mail si 123456 in campul cu parola.
• Faceti clic pe butonul „Conectare” din partea de jos a formularului.

Aceasta va afisa un ecran care spune ca procesul de autentificare a functionat, afisand profilul consolidat, dupa cum urmeaza:

In afara de utilizatorul care are un cont pe ambele aplicatii vechi, exista inca doi utilizatori care au conturi pe o aplicatie sau alta. [email protected] are un cont la prima aplicatie, dar nu si la a doua, iar [email protected] invers. Prin urmare, daca testam din nou procesul de autentificare cu unul dintre acesti utilizatori, vom termina cu profilul exact din aplicatia unde exista utilizatorul.

Gestionarea recuperarii parolelor

Fiind Auth0 o solutie pregatita pentru intreprindere pentru gestionarea identitatii, nu trebuie sa surprinda faptul ca caracteristici precum preluarea / resetarea parolelor sunt acceptate din cutie. Desi aceasta caracteristica este livrata in mod implicit, la contopirea profilurilor din mai multe surse de identitate, trebuie sa invatam Auth0 cum sa verifice daca un utilizator exista pe oricare dintre aceste surse. Pentru a face acest lucru, sa adaugam urmatorul cod la subsectiunea „Obtineti utilizator” din fila „Baza de date personalizata”:

functia getByEmail (email, callback) {“use strict”; const request = impune (‘[email protected]’); const Promise = impune (‘[email protected]’); const authenticate = Promise.coroutine (functie * () {const getTokenOptions = {metoda: ‘POST’, url: ‘https://bkrebs.auth0.com/oauth/token’, anteturi: {‘tipul de continut’: ‘ application / json ‘}, body:’ {“client_id”: “BvEdrxK2T2f36Hnttintbe4yIEjUC5P2”, “client_secret”: “13rf3mN0ciOEckabpE4TF4LYstBfOa19DYUBED7-MMzEM-CjR2ig” “” “” “” “” “” “” “” “” “” “” “” “” “” “” “” “” “” ” ; // primeste un token de acces pentru a comunica cu resursele de identitate mostenitoare const tokenResponse = cerere de randament (getTokenOptions); const accessToken = JSON.parse (tokenResponse). jeton de acces; // primeste profilul utilizatorului din ambele aplicatii let profileApp1 = {}; permiteti profilulApp2 = {}; incercati {profileApp1 = JSON.parse (randament legacyAuth (accessToken, ‘https://node-app-1.now.sh/users/’ + email)); } catch (e) {} try {profileApp2 = JSON.parse (randament legacyAuth (accessToken, ‘https://node-app-2.now.sh/users/’ + email)); } catch (e) {} // elimina proprietati nule din ambele profiluri pentru a face imbinarea (atribuirea) nestiind de ele Object.keys (profileApp1) .forEach ((key) => (profileApp1 [key] === null) && delete profileApp1 [tasta]); Object.keys (profileApp2) .forEach ((key) => (profileApp2 [key] === null) && delete profileApp2 [key]); // imbina ambele profiluri const profile = Object.assign ({}, profileApp1, profileApp2, {email}); returnare apel invers (nul, profil); }); autentifica(). catch (functia (e) {return return callback (noua eroare (e));}); function legacyAuth (accessToken, url) {const options = {metoda: ‘GET’, url: url, anteturi: {‘Autorizare’: ‘Portator’ + accessToken}}; cerere de returnare (optiuni); }}

Cititorii atenti vor observa ca codul pentru a verifica daca un utilizator exista pe oricare dintre sursele de identitate mostenitoare este destul de similar cu codul folosit pentru a conecta utilizatorii. Singura diferenta reala este ca in loc sa trimita credentiali utilizatorilor intr-o solicitare POST catre / utilizatori / autentificare, acum emitem o solicitare GET catre / utilizatori /: e-mail care inlocuieste: e-mail cu adresa de e-mail informata de utilizator. Cu acest cod in vigoare, Auth0 are acum mijloacele de a permite utilizatorilor sa creeze parole noi pentru conturile lor.

Refactorizarea aplicatiilor vechi pentru a utiliza Auth0

Pe langa implementarea scriptului de autentificare pentru a verifica acreditarile utilizatorului si a imbina profiluri din mai multe surse, trebuie sa refactam aplicatiile mostenite pentru a inlocui mecanismul de autentificare curent. Adica, de fiecare data cand utilizatorii ajung la aplicatie si incearca sa se autentifice, trebuie sa le aratam ecranul de autentificare Auth0 in locul celui vechi. Nu numai ca, aplicatia trebuie sa inteleaga ca utilizatorul este autentificat. Desi acest lucru poate parea o munca mai grea, Auth0 netezeste procesul de refactorizare prin furnizarea de biblioteci open source pentru cele mai frecvent utilizate tehnologii si furnizand documente si exemple excelente.

In directia Auth0 Docs, putem vedea ca tehnologiile sunt organizate in functie de tipul de aplicatie (Native App, SPAs, Web App si Backend). Selectarea unuia dintre aceste tipuri deschide o serie de tehnologii populare din care putem alege pentru a afla cum functioneaza integrarea. De exemplu, daca alegem tipul aplicatiei Web, vom vedea un ecran care contine documentatie pentru tehnologii precum ASP.NET, Apache, Go, Java, Node.js, PHP s.a.

Concluzie

Scenariul cu care s-a ocupat producatorul de hardware inainte de a trece la Auth0 este destul de comun. Companiile din intreaga lume au, de obicei, mai multe aplicatii care isi sustin operatiunile si, cel mai adesea, fiecare aplicatie contine propriul sistem de gestionare a identitatii. Aceasta situatie prezinta multe dezavantaje.

De exemplu, nu este banal sa tii evidenta mai multor acreditari raspandite in mai multe aplicatii. Cu cat adaugam mai multe aplicatii la operatiunile noastre zilnice, cu atat trebuie sa gestionam mai multe credente. In afara de aceasta, acest lucru poate introduce o problema de securitate, deoarece nu toti furnizorii de software au cunostintele necesare sau timpul necesar pentru a implementa toate masurile de securitate necesare pentru a pastra securitatea datelor noastre sensibile.

Din fericire, asa cum am vazut in acest articol, utilizarea Auth0 pentru a consolida identitatile din mai multe aplicatii este destul de simpla. In doar cateva minute putem configura un cont Auth0 care poate comunica la cat mai multe aplicatii mostenite necesare pentru a obtine utilizatorii si a contopi o singura sursa de adevar. Mai mult decat atat, faptul ca aveti un singur furnizor de identitate face mai usoara imbunatatirea securitatii cu functii precum autentificarea multifactor si fara parola.