Italian (Italiano) translation by Francesco (you can also view the original English article)
In questo articolo, esploreremo il servizio Auth0, che fornisce l'autenticazione e l'autorizzazione come servizio. Auth0 consente di impostare l'autenticazione di base e funzionalità di autorizzazioni per le app in un batter d'occhio.
Che cosa è Auth0?
Auth0 è uno strumento di autenticazione come servizio che rende l'implementazione di funzionalità di autenticazione nel vostro sito una brezza. Se hai costruito un app e desideri solo esternalizzare le funzionalità di autenticazione e autorizzazione, si dovrebbe considerare il servizio Auth0.
Permettetemi di riepilogare velocemente quello che Auth0 ha da offrire:
- Single sign-on
- autenticazione a più fattori
- account di accesso senza password
- gestione degli utenti
- e molto altro ancora
In questo articolo, andremo attraverso un paio di metodi single sign-on che è possibile implementare nelle tue applicazioni web al fine di sfruttare le funzionalità di autenticazione fornite dal servizio Auth0.
Nella prima metà di questo articolo, esploreremo come impostare funzionalità di autenticazione di base lato server in una web app PHP. Nella seconda metà, ti spiego come si potrebbero proteggere le vostre API personalizzate impostando l'autorizzazione OAuth utilizzando il servizio di Auth0.
Integrazione di autenticazione sul lato server
In questa sezione vedremo come rapidamente si potrebbe impostare l'autenticazione di base per applicazioni web lato server utilizzando Auth0. Infatti, il team di Auth0 già fornisce un utile esempio di GitHub che illustra esempi di base, in modo che useremo invece di reinventare la ruota.
Prima di procedere, assicurarsi di installare composer che verrà utilizzato per installare l'SDK di Auth0 utilizzando il file composer.json. Inoltre, se si desidera seguire gli esempi in questo articolo, andare avanti e creare un account gratuito con Auth0.
Impostare il progetto
Andiamo avanti e cloniamo il progetto di esempio.
1 |
git clone https://github.com/auth0-samples/auth0-php-web-app.git . |
Andare avanti con l'esecuzione del comando composer install per installare le dipendenze.
1 |
cd 00-Starter-Seed
|
2 |
composer install
|
In base al file composer.json, dovrebbe aver installato i pacchetti vlucas/phpdotenv e auth0/auth0-php.
1 |
{
|
2 |
"name": "auth0/basic-webapp-sample", |
3 |
"description": "Basic sample for securing a WebApp with Auth0", |
4 |
"require": { |
5 |
"vlucas/phpdotenv": "2.4.0", |
6 |
"auth0/auth0-php": "~5.0" |
7 |
},
|
8 |
"license": "MIT", |
9 |
"authors": [ |
10 |
{
|
11 |
"name": "Martin Gontovnikas", |
12 |
"email": "martin@gon.to" |
13 |
},
|
14 |
{
|
15 |
"name": "Germán Lena", |
16 |
"email": "german.lena@gmail.com" |
17 |
}
|
18 |
]
|
19 |
}
|
La libreria vlucas/phpdotenv viene utilizzata per inizializzare le variabili di ambiente dal file .env. Quindi, consente di separare la configurazione dal codice che cambia tra gli ambienti.
D'altra parte, il pacchetto di auth0/auth0-php è quello che ci aiuterà a impostare la pagina di autorizzazione nella nostra applicazione.
Successivamente, impostare la configurazione per la nostra applicazione nel file .env. Andare avanti e creare il file .env copiandolo dai file .env.example di esempio.
1 |
cp .env.example .env
|
Contiene i valori di configurazione che verranno utilizzati dalla libreria Auth0.
1 |
AUTH0_CLIENT_ID={CLIENT_ID}
|
2 |
AUTH0_DOMAIN={DOMAIN_NAME}
|
3 |
AUTH0_CLIENT_SECRET={CLIENT_SECRET}
|
4 |
AUTH0_CALLBACK_URL={CALLBACK_URL}
|
5 |
AUTH0_AUDIENCE= |
Si dovrebbe essere in grado di trovare la maggior parte delle impostazioni in Applicazioni > Default App > Impostazioni sul cruscotto Auth0. Siete pregati di notare che sto utilizzando l'applicazione predefinita creato dal sistema. Naturalmente, si potrebbe andare avanti e creare una nuova applicazione se si desidera farlo.
AUTH0_CALLBACK_URL è l'URL dell'applicazione dove Auth0 reindirizzerà gli utenti dopo il login e logout. Il valore impostato in questo campo deve essere configurato sotto gli URL di Callback ammessi sotto le impostazioni dell'applicazione sul cruscotto Auth0.
Troverete tre file principali che implementano la maggior parte della logica di autenticazione.
- index.php: questa è la pagina principale che Visualizza il pulsante di login o logout basato sullo stato dell'utente.
- login.php: questo script verrà avviato quando si fa clic sul pulsante login, e reindirizzerà gli utenti verso l'interfaccia di accesso Auth0 per accesso. Dopo il login, verranno reindirizzati su
AUTH0_CALLBACK_URL. - Logout.php: questo script verrà avviato quando si fa clic sul pulsante di logout, e andrà a reindirizzare gli utenti su Auth0 in background, disconnetterli e farli tornare alla
AUTH0_CALLBACK_URL.
File di progetto chiave
Andiamo rapidamente a vedere ogni file nel progetto di avviamento.
Lo Script di accesso
Inizieremo con il file login.php.
1 |
<?php
|
2 |
require __DIR__ . '/vendor/autoload.php'; |
3 |
require __DIR__ . '/dotenv-loader.php'; |
4 |
|
5 |
use Auth0\SDK\Auth0; |
6 |
|
7 |
$domain = getenv('AUTH0_DOMAIN'); |
8 |
$client_id = getenv('AUTH0_CLIENT_ID'); |
9 |
$client_secret = getenv('AUTH0_CLIENT_SECRET'); |
10 |
$redirect_uri = getenv('AUTH0_CALLBACK_URL'); |
11 |
$audience = getenv('AUTH0_AUDIENCE'); |
12 |
|
13 |
if($audience == ''){ |
14 |
$audience = 'https://' . $domain . '/userinfo'; |
15 |
}
|
16 |
|
17 |
$auth0 = new Auth0([ |
18 |
'domain' => $domain, |
19 |
'client_id' => $client_id, |
20 |
'client_secret' => $client_secret, |
21 |
'redirect_uri' => $redirect_uri, |
22 |
'audience' => $audience, |
23 |
'scope' => 'openid profile', |
24 |
'persist_id_token' => true, |
25 |
'persist_access_token' => true, |
26 |
'persist_refresh_token' => true, |
27 |
]);
|
28 |
|
29 |
$auth0->login(); |
All'inizio, abbiamo incluso i caricatori automatici che sono responsabili per il caricamento di Auth0 e le variabile di ambiente delle classi correlate. In seguito, inizializziamo le variabili di configurazione dal file .env utilizzando la funzione getenv.
Successivamente, dobbiamo istanziare l'oggetto Auth0 e chiamare il metodo di login che reindirizza gli utenti a Auth0 per il login. Al momento del login, l'utente verrà rimandato indietro al nostro sito.
Si può accedere utilizzando il tuo account di social come Facebook, Google e simili, o creare un nuovo account durante l'accesso. In entrambi i casi, Auth0 creerà record per i nuovi utenti il loro fine. È possibile abilitare social login diversi sotto Connessioni > social sul cruscotto Auth0. Inoltre, è possibile controllare l'elenco degli utenti che sono connessi utilizzando Auth0 sul cruscotto Auth0 sotto il collegamento Utenti.
Lo Script di disconnessione
Successivamente, diamo un'occhiata veloce al file logout.php.
1 |
<?php
|
2 |
require __DIR__ . '/vendor/autoload.php'; |
3 |
require __DIR__ . '/dotenv-loader.php'; |
4 |
use Auth0\SDK\Auth0; |
5 |
|
6 |
$domain = getenv('AUTH0_DOMAIN'); |
7 |
$client_id = getenv('AUTH0_CLIENT_ID'); |
8 |
$client_secret = getenv('AUTH0_CLIENT_SECRET'); |
9 |
$redirect_uri = getenv('AUTH0_CALLBACK_URL'); |
10 |
$audience = getenv('AUTH0_AUDIENCE'); |
11 |
|
12 |
if($audience == ''){ |
13 |
$audience = 'https://' . $domain . '/userinfo'; |
14 |
}
|
15 |
|
16 |
$auth0 = new Auth0([ |
17 |
'domain' => $domain, |
18 |
'client_id' => $client_id, |
19 |
'client_secret' => $client_secret, |
20 |
'redirect_uri' => $redirect_uri, |
21 |
'audience' => $audience, |
22 |
'scope' => 'openid profile', |
23 |
'persist_id_token' => true, |
24 |
'persist_refresh_token' => true, |
25 |
]);
|
26 |
|
27 |
$auth0->logout(); |
28 |
$return_to = 'https://' . $_SERVER['HTTP_HOST']; |
29 |
$logout_url = sprintf('http://%s/v2/logout?client_id=%s&returnTo=%s', $domain, $client_id, $return_to); |
30 |
header('Location: ' . $logout_url); |
31 |
die(); |
Questo funziona più o meno come il file login.php, tranne che sarà chiamato quando gli utenti si disconnettono. Viene chiamato il metodo logout per far scadere la sessione utente nella tua app. In seguito, l'utente verrà reindirizzato a Auth0 affinché il servizio sia informato sull'attività logout dell'utente. Infine, l'utente verrà reindirizzato all'applicazione.
Il File Index
Infine, vediamo il file index.php, che è il punto di ingresso della nostra applicazione.
1 |
<?php
|
2 |
// Require composer autoloader
|
3 |
require __DIR__ . '/vendor/autoload.php'; |
4 |
require __DIR__ . '/dotenv-loader.php'; |
5 |
use Auth0\SDK\Auth0; |
6 |
$domain = getenv('AUTH0_DOMAIN'); |
7 |
$client_id = getenv('AUTH0_CLIENT_ID'); |
8 |
$client_secret = getenv('AUTH0_CLIENT_SECRET'); |
9 |
$redirect_uri = getenv('AUTH0_CALLBACK_URL'); |
10 |
$audience = getenv('AUTH0_AUDIENCE'); |
11 |
if($audience == ''){ |
12 |
$audience = 'https://' . $domain . '/userinfo'; |
13 |
}
|
14 |
$auth0 = new Auth0([ |
15 |
'domain' => $domain, |
16 |
'client_id' => $client_id, |
17 |
'client_secret' => $client_secret, |
18 |
'redirect_uri' => $redirect_uri, |
19 |
'audience' => $audience, |
20 |
'scope' => 'openid profile', |
21 |
'persist_id_token' => true, |
22 |
'persist_access_token' => true, |
23 |
'persist_refresh_token' => true, |
24 |
]);
|
25 |
$userInfo = $auth0->getUser(); |
26 |
?>
|
27 |
<html>
|
28 |
<head>
|
29 |
<script src="http://code.jquery.com/jquery-3.1.0.min.js" type="text/javascript"></script> |
30 |
|
31 |
<meta name="viewport" content="width=device-width, initial-scale=1"> |
32 |
|
33 |
<!-- font awesome from BootstrapCDN -->
|
34 |
<link href="//maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css" rel="stylesheet"> |
35 |
<link href="//maxcdn.bootstrapcdn.com/font-awesome/4.5.0/css/font-awesome.min.css" rel="stylesheet"> |
36 |
|
37 |
<link href="public/app.css" rel="stylesheet"> |
38 |
</head>
|
39 |
<body class="home"> |
40 |
<div class="container"> |
41 |
<div class="login-page clearfix"> |
42 |
<?php if(!$userInfo): ?> |
43 |
<div class="login-box auth0-box before"> |
44 |
<img src="https://i.cloudup.com/StzWWrY34s.png" /> |
45 |
<h3>Auth0 Example</h3> |
46 |
<p>Zero friction identity infrastructure, built for developers</p> |
47 |
<a class="btn btn-primary btn-lg btn-login btn-block" href="login.php">Sign In</a> |
48 |
</div>
|
49 |
<?php else: ?> |
50 |
<div class="logged-in-box auth0-box logged-in"> |
51 |
<h1 id="logo"><img src="//cdn.auth0.com/samples/auth0_logo_final_blue_RGB.png" /></h1> |
52 |
<img class="avatar" src="<?php echo $userInfo['picture'] ?>"/> |
53 |
<h2>Welcome <span class="nickname"><?php echo $userInfo['nickname'] ?></span></h2> |
54 |
<a class="btn btn-warning btn-logout" href="/logout.php">Logout</a> |
55 |
</div>
|
56 |
<?php endif ?> |
57 |
</div>
|
58 |
</div>
|
59 |
</body>
|
60 |
</html>
|
Qui, abbiamo utilizzato il metodo getUser dell'oggetto $auth0 per vedere se c'è una sessione attiva. Se non c'è nessuna sessione attiva, viene visualizzato il collegamento Sign In, che porta l'utente a login.php e avvia il flusso di accesso. Dall'altra parte, salutiamo l'utente e visualizziamo il collegamento di disconnessione se l'utente è già connesso.
Questa è l'implementazione di un flusso di autenticazione di base per le applicazioni lato server.
Proteggere la vostra API personalizzata con OAuth2
In questa sezione, vedremo come si possono proteggere le API personalizzate implementando il flusso OAuth2 per la concessione di codice di autorizzazione. Spero che tu abbia familiarità con il flusso standard della concessione del codice di autorizzazione dato che noi non entreremo nei dettagli di questo. Scopri alcuni dei nostri altri post qui su Envato Tuts+ se vuoi approfondire OAuth2.
Invece, ci immergeremo subito nell'implementazione effettiva. Andare avanti e creare un file auth_code_grant_example.php con il seguente contenuto.
1 |
<?php
|
2 |
session_start(); |
3 |
|
4 |
if (!isset($_GET['code'])) { |
5 |
// Check if we need to show the "Sign In" link
|
6 |
$params = array ( |
7 |
'audience' => '{AUDIENCE}', |
8 |
'scope' => 'profile', |
9 |
'response_type' => 'code', |
10 |
'client_id' => '{CLIENT_ID}', |
11 |
'state' => 'SomeRandomString', |
12 |
'redirect_uri' => '{CALLBACK_URL}' |
13 |
);
|
14 |
|
15 |
$_SESSION['oauth2state']=$params['state']; |
16 |
$str_params = ''; |
17 |
foreach($params as $key=>$value) { |
18 |
$str_params .= $key . "=" . urlencode($value) . "&"; |
19 |
}
|
20 |
?>
|
21 |
|
22 |
<a href="https://{AUTH0_DOMAIN}/authorize?<?php echo $str_params;?>"> |
23 |
Sign In |
24 |
</a>
|
25 |
<?php
|
26 |
} elseif (empty($_GET['state']) || (isset($_SESSION['oauth2state']) && $_GET['state'] !== $_SESSION['oauth2state'])) { |
27 |
// If the "state" var is present in the $_GET, let's validate it
|
28 |
if (isset($_SESSION['oauth2state'])) { |
29 |
unset($_SESSION['oauth2state']); |
30 |
}
|
31 |
|
32 |
exit('Invalid state'); |
33 |
|
34 |
} elseif(isset($_GET['code']) && !empty($_GET['code'])) { |
35 |
// If the auth "code" is present in the $_GET
|
36 |
// let's exchange it for the access token
|
37 |
$params = array ( |
38 |
'grant_type' => 'authorization_code', |
39 |
'client_id' => '{CLIENT_ID}', |
40 |
'client_secret' => '{CLIENT_SECRET}', |
41 |
'code' => $_GET['code'], |
42 |
'redirect_uri' => '{CALLBACK_URL}' |
43 |
);
|
44 |
|
45 |
$str_params = ''; |
46 |
foreach($params as $key=>$value) { |
47 |
$str_params .= $key . "=" . urlencode($value) . "&"; |
48 |
}
|
49 |
|
50 |
$curl = curl_init(); |
51 |
|
52 |
curl_setopt_array($curl, array( |
53 |
CURLOPT_URL => "https://{AUTH0_DOMAIN}/oauth/token", |
54 |
CURLOPT_RETURNTRANSFER => true, |
55 |
CURLOPT_CUSTOMREQUEST => "POST", |
56 |
CURLOPT_POSTFIELDS => $str_params |
57 |
));
|
58 |
|
59 |
$curl_response = curl_exec($curl); |
60 |
$curl_error = curl_error($curl); |
61 |
|
62 |
curl_close($curl); |
63 |
|
64 |
if ($curl_error) { |
65 |
echo "Error in the CURL response:" . $curl_error; |
66 |
} else { |
67 |
$arr_json_data = json_decode($curl_response); |
68 |
|
69 |
if (isset($arr_json_data->access_token)) { |
70 |
$access_token = $arr_json_data->access_token; |
71 |
$curl = curl_init(); |
72 |
|
73 |
curl_setopt_array($curl, array( |
74 |
CURLOPT_URL => "http://{YOUR_API_DOMAIN}/demo_api_server.php", |
75 |
CURLOPT_RETURNTRANSFER => true, |
76 |
CURLOPT_CUSTOMREQUEST => "GET", |
77 |
CURLOPT_HTTPHEADER => array( |
78 |
"Authorization: Bearer {$access_token}" |
79 |
)
|
80 |
));
|
81 |
|
82 |
$curl_response = curl_exec($curl); |
83 |
$curl_error = curl_error($curl); |
84 |
|
85 |
curl_close($curl); |
86 |
|
87 |
if ($curl_error) { |
88 |
echo "Error in the CURL response from DEMO API:" . $curl_error; |
89 |
} else { |
90 |
echo "Demo API Response:" . $curl_response; |
91 |
}
|
92 |
} else { |
93 |
echo 'Invalid response, no access token was found.'; |
94 |
}
|
95 |
}
|
96 |
}
|
Diamo un'occhiata a come funziona questo codice!
Iniziamo il flusso di autorizzazione
In primo luogo, abbiamo preparato un collegamento che invia l'utente al server Auth0 per avviare il flusso di autorizzazione.
1 |
// Check if we need to show the "Sign In" link
|
2 |
$params = array ( |
3 |
'audience' => '{AUDIENCE}', |
4 |
'scope' => 'profile', |
5 |
'response_type' => 'code', |
6 |
'client_id' => '{CLIENT_ID}', |
7 |
'state' => '{SOME_RANDOM_STRING}', |
8 |
'redirect_uri' => '{CALLBACK_URL}' |
9 |
);
|
10 |
|
11 |
$_SESSION['oauth2state']=$params['state']; |
12 |
$str_params = ''; |
13 |
foreach($params as $key=>$value) { |
14 |
$str_params .= $key . "=" . urlencode($value) . "&"; |
15 |
}
|
16 |
?>
|
17 |
|
18 |
<a href="https://{AUTH0_DOMAIN}/authorize?<?php echo $str_params;?>"> |
19 |
Sign In |
20 |
</a>
|
Si prega di sostituire {AUDIENCE}, {CLIENT_ID} e {CALLBACK_URL} con valori corrispondenti all'applicazione. Il parametro {AUDIENCE} deve essere sostituito con il valore del campo dell'identificatore trovato sotto API > {applicazione API} > impostazioni sul cruscotto Auth0.
{SOME_RANDOM_STRING} deve essere sostituito con un valore univoco che è difficile da indovinare. Questa stringa viene utilizzata per prevenire attacchi CSRF. Inoltre, assicurarsi di sostituire {AUTH0_DOMAIN con il nome di dominio, come abbiamo discusso in precedenza.
Ottenere il Token di accesso
Quando un utente fa clic sul link Sign In, verrà indirizzati al server Auth0 per l'autenticazione. Dopo l'autenticazione, gli verrà chiesto di autorizzare l'accesso dell'applicazione al tuo profilo. Dopo l'autorizzazione, l'utente verrà reindirizzato all'applicazione con il code come parametro $_Get.
Successivamente, possiamo scambiare questo code per ottenere il token di accesso.
1 |
// If the auth "code" is present in the $_GET
|
2 |
// let's exchange it for the access token
|
3 |
$params = array ( |
4 |
'grant_type' => 'authorization_code', |
5 |
'client_id' => '{CLIENT_ID}', |
6 |
'client_secret' => '{CLIENT_SECRET}', |
7 |
'code' => $_GET['code'], |
8 |
'redirect_uri' => '{CALLBACK_URL}' |
9 |
);
|
10 |
|
11 |
$str_params = ''; |
12 |
foreach($params as $key=>$value) { |
13 |
$str_params .= $key . "=" . urlencode($value) . "&"; |
14 |
}
|
15 |
|
16 |
$curl = curl_init(); |
17 |
$curl_response = curl_exec($curl); |
18 |
|
19 |
curl_setopt_array($curl, array( |
20 |
CURLOPT_URL => "https://{AUTH0_DOMAIN}/oauth/token", |
21 |
CURLOPT_RETURNTRANSFER => true, |
22 |
CURLOPT_CUSTOMREQUEST => "POST", |
23 |
CURLOPT_POSTFIELDS => $str_params |
24 |
));
|
Come potete vedere, ci vuole una singola chiamata CURL per recuperare il token di accesso.
Chiamare l'Endpoint API personalizzato
Una volta che avete il token di accesso, è possibile chiamare l'endpoint API personalizzato includendolo nell'intestazione.
1 |
$access_token = $arr_json_data->access_token; |
2 |
$curl = curl_init(); |
3 |
|
4 |
curl_setopt_array($curl, array( |
5 |
CURLOPT_URL => "http://{YOUR_API_DOMAIN}/demo_api_server.php", |
6 |
CURLOPT_RETURNTRANSFER => true, |
7 |
CURLOPT_CUSTOMREQUEST => "GET", |
8 |
CURLOPT_HTTPHEADER => array( |
9 |
"Authorization: Bearer {$access_token}" |
10 |
)
|
11 |
));
|
12 |
|
13 |
$curl_response = curl_exec($curl); |
14 |
$curl_error = curl_error($curl); |
15 |
|
16 |
curl_close($curl); |
17 |
|
18 |
if ($curl_error) { |
19 |
echo "Error in the CURL response from DEMO API:" . $curl_error; |
20 |
} else { |
21 |
echo "Demo API Response:" . $curl_response; |
22 |
}
|
Un Endpoint di API protetto da Auth0
La risorsa API fittizia nel file demo_api_server.php potrebbe essere simile a questa:
1 |
<?php
|
2 |
// Require composer autoloader
|
3 |
require __DIR__ . '/vendor/autoload.php'; |
4 |
|
5 |
use Auth0\SDK\JWTVerifier; |
6 |
|
7 |
try { |
8 |
$verifier = new JWTVerifier([ |
9 |
'supported_algs' => ['{HASHING_ALGORITHM}'], |
10 |
'valid_audiences' => ['{AUDIENCE}'], |
11 |
'authorized_iss' => ['{DOMAIN}'] |
12 |
]);
|
13 |
|
14 |
$access_token = getBearerToken(); |
15 |
$token_info = $verifier->verifyAndDecode($access_token); |
16 |
|
17 |
echo json_encode(array('date'=>'API Resource Data!!')); |
18 |
}
|
19 |
catch(\Auth0\SDK\Exception\CoreException $e) { |
20 |
throw $e; |
21 |
echo json_encode(array('error'=>$e->getMessage())); |
22 |
}
|
23 |
|
24 |
function getAuthorizationHeader() { |
25 |
$headers = null; |
26 |
|
27 |
if (isset($_SERVER['Authorization'])) { |
28 |
$headers = trim($_SERVER["Authorization"]); |
29 |
}
|
30 |
else if (isset($_SERVER['HTTP_AUTHORIZATION'])) { //Nginx or fast CGI |
31 |
$headers = trim($_SERVER["HTTP_AUTHORIZATION"]); |
32 |
} elseif (function_exists('apache_request_headers')) { |
33 |
$requestHeaders = apache_request_headers(); |
34 |
// Server-side fix for bug in old Android versions (a nice side-effect of this fix means we don't care about capitalization for Authorization)
|
35 |
$requestHeaders = array_combine(array_map('ucwords', array_keys($requestHeaders)), array_values($requestHeaders)); |
36 |
//print_r($requestHeaders);
|
37 |
if (isset($requestHeaders['Authorization'])) { |
38 |
$headers = trim($requestHeaders['Authorization']); |
39 |
}
|
40 |
}
|
41 |
return $headers; |
42 |
}
|
43 |
|
44 |
function getBearerToken() { |
45 |
$headers = getAuthorizationHeader(); |
46 |
|
47 |
// HEADER: Get the access token from the header
|
48 |
if (!empty($headers)) { |
49 |
if (preg_match('/Bearer\s(\S+)/', $headers, $matches)) { |
50 |
return $matches[1]; |
51 |
}
|
52 |
}
|
53 |
return null; |
54 |
}
|
Vediamo rapidamente le parti importanti di questo codice.
Convalidare il Token di accesso
È vostra responsabilità di convalidare il token di accesso in ingresso prima di concedere l'accesso alla risorsa protetta. E questo è esattamente quello che abbiamo fatto nel frammento seguente. Abbiamo utilizzato la classe di utilità JWTVerifier per convalidare il token di accesso.
1 |
try { |
2 |
$verifier = new JWTVerifier([ |
3 |
'supported_algs' => ['{SIGNING_ALGORITHM}'], |
4 |
'valid_audiences' => ['{AUDIENCE}'], |
5 |
'authorized_iss' => ['{DOMAIN}'] |
6 |
]);
|
7 |
|
8 |
$access_token = getBearerToken(); |
9 |
$token_info = $verifier->verifyAndDecode($access_token); |
10 |
|
11 |
echo json_encode(array('date'=>'API Resource Data!!')); |
12 |
}
|
13 |
catch(\Auth0\SDK\Exception\CoreException $e) { |
14 |
throw $e; |
15 |
echo json_encode(array('error'=>$e->getMessage())); |
16 |
}
|
{SIGNING_ALGORITHM} deve essere sostituito con il valore del campo Signing Algorithm trovato sotto API > {applicazione API} > Impostazioni.
Quindi, ecco come è possibile proteggere le vostre API personalizzate se si desidera utilizzare il flusso di OAuth2 nel servizio Auth0.
Conclusione
Oggi, abbiamo esplorato il servizio Auth0, che fornisce l'autenticazione e l'autorizzazione come servizio. Dopo aver introdotto il servizio di Auth0, abbiamo visto un paio di esempi pratici per dimostrare come si potrebbe integrare con le applicazioni PHP.
Sentitevi liberi di inviare i vostri suggerimenti e le domande utilizzando il feed qui sotto!
By
