1. Authentification d'une application Node.js avec Oracle Identity Cloud Service
  2. En savoir plus sur l'authentification entre les applications Node.js et Oracle Identity Cloud Service

En savoir plus sur l'authentification entre les applications Node.js et Oracle Identity Cloud Service

Vous êtes prêt à en savoir plus sur l'authentification entre les applications Web Node.js et Oracle Identity Cloud Service. Cela inclut la compréhension des éléments suivants :

  • Flux d'authentification à trois éléments pris en charge par Oracle Identity Cloud Service pour le kit SDK Node.js

  • Cas d'emploi de l'utilisation d'un kit SDK avec une application Node.js pour l'authentification avec Oracle Identity Cloud Service

  • Méthodes et fonctions du kit SDK Node.js

En savoir plus sur les flux d'authentification à trois éléments

Oracle Identity Cloud Service prend en charge le flux d'authentification à trois éléments pour le kit SDK Node.js. Dans ce flux, les utilisateurs interagissent directement avec Oracle Identity Cloud Service. Une fois qu'un utilisateur se connecte, Oracle Identity Cloud Service émet un code d'autorisation que le kit SDK échange pour un jeton d'accès utilisateur. L'application Web Node.js utilise ce jeton d'accès pour accorder aux utilisateurs l'accès aux ressources protégées de l'application. Le flux à trois pattes utilise le type d'octroi de code d'autorisation.

Pour une sécurité accrue, Oracle recommande d'utiliser le flux à trois éléments afin d'intégrer vos applications Web Node.js à Oracle Identity Cloud Service à des fins d'authentification. En utilisant le type d'octroi de code d'autorisation, vous pouvez également accéder à d'autres applications protégées par Oracle Identity Cloud Service sans avoir à vous réauthentifier.

En savoir plus sur les cas d'utilisation principaux pour l'utilisation d'un kit SDK avec une application Node.js

L'application Web Node.js implémente deux cas d'emploi : l'un pour authentifier les utilisateurs et l'autre pour accéder à des informations détaillées sur l'utilisateur connecté.

Les diagrammes de flux de données suivants illustrent le flux d'événements, d'appels et de réponses entre le navigateur Web, l'application Web et Oracle Identity Cloud Service pour chaque cas d'emploi.

Cas d'utilisation n° 1 : Authentifier un utilisateur

Description de l'image authenticate-user.png
Description de l'illustration authenticate-user.png

Le flux de données se produit de cette manière :

  1. L'utilisateur demande une ressource protégée.

  2. Le module d'authentification utilise le kit SDK pour générer une URL de code d'autorisation de demande pour Oracle Identity Cloud Service et envoyer cette URL en tant que réponse de redirection vers le navigateur Web.

  3. Le navigateur Web appelle l'URL.

  4. La page Connexion Oracle Identity Cloud Service apparaît.

  5. L'utilisateur soumet ses informations d'identification de connexion Oracle Identity Cloud Service.

  6. Une fois l'utilisateur connecté, Oracle Identity Cloud Service crée une session pour l'utilisateur et émet un code d'autorisation.

  7. L'application Web effectue un appel back-end (ou serveur à serveur) pour échanger le code d'autorisation contre un jeton d'accès.

  8. Oracle Identity Cloud Service émet un jeton d'accès et un jeton d'ID.

  9. Une session est établie et l'utilisateur est redirigé vers la page d'accueil.

  10. La page d'accueil de l'application Web apparaît.

Cas d'utilisation n° 2 : obtenir des détails sur l'utilisateur

Description de l'image get-details-user.png
Description de l'illustration get-details-user.png

Le flux de données se produit de cette manière :

  1. L'utilisateur demande la ressource /myProfile.

  2. L'application Web utilise le kit SDK d'Oracle Identity Cloud Service pour valider le jeton d'ID.

  3. Les données renvoyées par la validation de jeton d'ID contiennent les détails de l'utilisateur au format d'un objet JSON.

  4. La page Mon profil affiche l'objet JSON en tant que contenu HTML.

En savoir plus sur les méthodes et les fonctions

Le kit SDK Node.js est une stratégie de passeport Node.js que vous ajoutez à votre dossier Node.js modules. Ce kit SDK est également basé sur les promesses Node.js.

Toutes les dépendances tierces dont le kit SDK Node.js a besoin sont définies dans le fichier package.json du kit SDK dans le fichier ZIP de kit SDK Node.js que vous téléchargez à partir de la console Oracle Identity Cloud Service. Vous devez utiliser au moins cet ensemble de modules dans votre application Web Node.js. 

"dependencies": {
    "async": "^2.1.2",
    "bunyan": "^1.8.5",
    "cache-manager": "^2.2.0",
    "json-web-token": "^2.1.3",
    "jsonwebtoken": "^8.2.1",
    "jwk-to-pem": "^1.2.6",
    "jws": "^3.1.5",
    "lru": "^3.1.0",
    "passport": "^0.4.0",
    "promise": "^8.0.1",
    "querystring": "^0.2.0",
    "request": "^2.81.0",
    "rsa-pem-to-jwk": "^1.1.3",
    "util": "^0.10.3"
  },

Une application Web Node.js a été développée à l'aide des modules Node.js express et express-handlebars, qui implémente des routages d'URL sous la forme d'une fonction app.get() pour chaque URL.

Le kit SDK Node.js requiert une variable JSON chargée avec les informations de connexion Oracle Identity Cloud Service. L'application Web Node.js utilise la variable ids pour stocker les informations suivantes : 

var ids = {
    oracle: {
    "ClientId": "123456789abcdefghij'",
    "ClientSecret": "abcde-12345-zyxvu-98765-qwerty",
    "ClientTenant": "idcs-abcd1234",
    "IDCSHost": "https://%tenant%.identity.oraclecloud.com",
    "AudienceServiceUrl" : "https://idcs-abcd1234.identity.oraclecloud.com",
    "TokenIssuer": "https://identity.oraclecloud.com/",
    "scope": "urn:opc:idm:t.user.me openid",
    "logoutSufix": "/oauth2/v1/userlogout",
    "redirectURL": "http://localhost:3000/callback",
    "LogLevel":"INFO",
    "ConsoleLog":"True"
    }
};
module.exports = ids;

Voici une brève explication de chaque attribut requis pour ce kit SDK :

Nom Description
ClientId Valeur de l'ID client générée après l'inscription de l'application Web Node.js dans la console Oracle Identity Cloud Service.
ClientSecret Valeur de la clé secrète client générée après l'inscription de l'application Web Node.js dans la console Oracle Identity Cloud Service.
ClientTenant Préfixe de domaine de votre instance Oracle Identity Cloud Service. Ce préfixe est généralement similaire à idcs-abcd1234.
IDCSHost Suffixe de domaine de votre instance Oracle Identity Cloud Service. Lors de l'exécution, l'espace réservé %tenant% est remplacé par la valeur de l'attribut ClientTenant.
AudienceServiceUrl URL de nom de domaine qualifié complet de votre instance Oracle Identity Cloud Service.
TokenIssuer Pour cet attribut, Oracle recommande de conserver la valeur https://identity.oraclecloud.com/.
scope

La portée contrôle les données auxquelles l'application peut accéder ou traiter pour le compte de l'utilisateur Oracle Identity Cloud Service.

Si l'application utilise le kit SDK pour authentifier un utilisateur, la portée est openid. Si l'application utilise le kit SDK pour obtenir des détails sur l'utilisateur, la portée est urn:opc:idm:t.user.me openid.

ConsoleLog Active le journal SDK.
LogLevel Indique le niveau de journalisation du kit SDK.

L'application utilise les attributs logoutSufix et redirectURL pour éviter de coder ces valeurs en dur. Le SDK n'en a pas besoin.

L'application Node.js implémente le routage d'URL /oauth/oracle. Lorsqu'un utilisateur s'authentifie auprès d'Oracle Identity Cloud Service, le navigateur Web envoie une demande GET à cette URL. Ce routage utilise le kit SDK pour générer l'URL d'autorisation d'Oracle Identity Cloud Service. 

//Loading the configurations
var auth = require('./auth.js');
 
//Route for /oauth/oracle
app.get("/auth/oracle", function(req, res){
    //Authentication Manager loaded with the configurations.
    am = new IdcsAuthenticationManager(auth.oracle);
    //Using Authentication Manager to generate the Authorization Code URL, passing the
    //application's callback URL as parameter, along with code value and code parameter.
    am.getAuthorizationCodeUrl(auth.oracle.redirectURL, auth.oracle.scope, "1234", "code")
        .then(function(authZurl){
            //Redirecting the browser to the Oracle Identity Cloud Service Authorization URL.
            res.redirect(authZurl);
        }).catch(function(err){
            res.end(err);
        })
});

Cette fonction charge les paramètres JSON vers une variable, initialise un gestionnaire d'authentification et utilise la fonction IdcsAuthenticationManager.getAuthorizationCodeUrl() du kit SDK Node.js pour générer l'URL de code d'autorisation. Cette fonction utilise la promesse de rediriger le navigateur Web de l'utilisateur lorsque l'URL du code d'autorisation est générée ou d'afficher une erreur dans le navigateur.

Les paramètres suivants sont utilisés pour générer l'URL du code d'autorisation :

Nom Description
auth.oracle.redirectURL Une fois qu'un utilisateur se connecte, Oracle Identity Cloud Service redirige le navigateur Web de l'utilisateur vers cette URL. Cette URL doit correspondre à celle que vous allez configurer pour l'application sécurisée dans la console Identity Cloud Service. Pour plus d'informations sur la spécification d'une URL de redirection pour l'application Web Node.js, reportez-vous à Inscription de l'application Node.js.
auth.oracle.scope Portée d'authentification OAuth ou OpenID Connect. Cette application requiert uniquement l'authentification openid.
state Le protocole OAuth définit ce paramètre. L'exemple d'application Web Node.js utilise ce code pour vérifier si la communication peut être établie avec Oracle Identity Cloud Service. Pour cet exemple, la valeur de ce paramètre est 1234.
response_type Paramètre requis par le type d'octroi du code d'autorisation. Pour cet exemple, la valeur de ce paramètre est code.

Une fois l'utilisateur connecté, Oracle Identity Cloud Service redirige le navigateur Web de l'utilisateur vers une URL de callback, que le développeur doit implémenter. L'application Web Node.js utilise le routage /callback pour gérer cette demande. 

//Route for /callback
app.get("/callback", function(req,res){
    //Authentication Manager loaded with the configurations.
    var am = new IdcsAuthenticationManager(auth.oracle);
    //Getting the authorization code from the "code" parameter
    var authZcode = req.query.code;
    //Using the Authentication Manager to exchange the Authorization Code to an Access Token.
    am.authorizationCode(authZcode)
        .then(function(result){
            //Getting the Access and Id Token Values to set in the session.
            req.session.access_token = result.access_token;
            req.session.id_token = result.id_token;
            res.cookie(config.IDCS_COOKIE_NAME, result.access_token);
            res.header('idcs_user_assertion', result.access_token)
            res.redirect('/auth.html');
        }).catch(function(err){
            res.end(err);
        })
});

L'application Node.js utilise le code d'autorisation pour demander un jeton d'accès. Le jeton d'accès est stocké sous forme de cookie, qui est ensuite envoyé au navigateur Web pour une utilisation ultérieure.

La fonction IdcsAuthenticationManager.authorizationCode() du kit SDK Node.js utilise également promise (une instruction then-catch) pour définir le jeton d'accès en tant que cookie et pour rediriger le navigateur vers la page /auth.html.

Le kit SDK Node.js est basé sur la structure de passeport Node.js. Par conséquent, le navigateur doit transmettre le jeton d'accès en tant que variable d'en-tête au gestionnaire d'URL /auth et utiliser la méthode passport.authenticate() avec le nom de stratégie Oracle Identity Cloud Service en tant que paramètre : 

//Uses passport to create a User Session in Node.js.
//Passport sets a user attribute in the request as a json object.
app.get('/auth', passport.authenticate(config.IDCS_STRATEGY_NAME, {}), function(req, res) {
   res.redirect('/home');
});

Une fois que la méthode passport.authenticate() a créé la session de l'application, la fonction redirige le navigateur Web de l'utilisateur vers une URL protégée dans l'application /home. En plus de /home, l'application Web Node.js dispose d'une autre URL protégée : /myProfile.

Toute URL protégée doit vérifier si la session de l'utilisateur a été créée précédemment. La fonction suivante est utilisée par chaque fonction app.get() pour ces URL. 

function ensureAuthenticated(req, res, next) {
   if (req.isAuthenticated()) {
      return next();
   }
   res.redirect('/login')
}

L'application Node.js gère le routage /myProfile et obtient les informations définies dans la session, comme suit : 

app.get("/myProfile", ensureAuthenticated, function(req,res){
   //User Manager loaded with the configurations
   var am = new IdcsAuthenticationManager(auth.oracle);
   //Validating id token to acquire information such as UserID, DisplayName, list of groups and AppRoles assigned to the user.
   am.validateIdToken(req.session['id_token'])
    .then(function(idToken){
      res.render('myProfile', {
         layout: 'privateLayout',
         title: 'My Profile',
         user: req.user,
         userInfo: JSON.stringify(idToken, null, 2)
         });
    }).catch(function(err1){
       res.end(err1);
   })
});

Après l'initialisation de l'objet IdcsAuthenticationManager, le gestionnaire du routage /myProfile utilise la fonction IdcsAuthenticationManager.validateIdToken() du kit SDK pour acquérir des informations utilisateur telles que le nom d'affichage, l'ID utilisateur et la liste des groupes et des rôles d'application affectés à l'utilisateur. L'objet JSON est ensuite analysé en tant que chaîne dans le fichier myProfile.handlebars pour être affiché dans le navigateur Web.

Pour vous déconnecter de l'accès avec connexion unique entre l'application et Oracle Identity Cloud Service, l'application Web Node.js implémente le routage /logout, comme suit : 

app.get('/logout', function(req, res){
  var id_token = req.session.id_token;
  var logouturl = auth.oracle.AudienceServiceUrl + auth.oracle.logoutSufix + '?post_logout_redirect_uri=http%3A//localhost%3A3000&id_token_hint='+ id_token;
  req.session.destroy(function(err) {
    if(err) {
      console.log(err);
    } else {
      req.logout();
      res.clearCookie();
      res.redirect(logouturl);
    }
  })
});

Ce routage invalide la session de l'application, enlève les objets et les cookies définis précédemment, puis redirige le navigateur Web de l'utilisateur vers l'URL de déconnexion OAuth d'Oracle Identity Cloud Service.