1. Authentifier 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 comprend les éléments suivants :

  • Flux d'authentification à trois branches pris en charge par Oracle Identity Cloud Service pour la trousse SDK Node.js

  • Cas d'utilisation pour l'utilisation d'une trousse SDK avec une application Node.js pour l'authentification avec Oracle Identity Cloud Service

  • Méthodes et fonctions de la trousse SDK Node.js

En savoir plus sur les flux d'authentification à trois branches

Oracle Identity Cloud Service prend en charge le flux d'authentification à trois branches pour la trousse SDK Node.js. Dans ce flux, les utilisateurs interagissent directement avec Oracle Identity Cloud Service. Après la connexion d'un utilisateur, Oracle Identity Cloud Service émet un code d'autorisation que la trousse SDK échange pour un jeton d'accès d'utilisateur. L'application Web Node.js utilise ce jeton d'accès pour accorder aux utilisateurs l'accès aux ressources protégées dans l'application. Le flux à trois parties utilise le type d'octroi de code d'autorisation.

Pour une sécurité accrue, Oracle recommande d'utiliser le flux à trois branches pour intégrer vos applications Web Node.js à Oracle Identity Cloud Service pour l'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'une trousse SDK avec une application Node.js

L'application Web Node.js met en oeuvre deux cas d'utilisation : l'un pour l'authentification des utilisateurs et l'autre pour l'accès à 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'utilisation.

Cas d'utilisation n° 1 : Authentifier un utilisateur

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

Le flux de données se déroule de la façon suivante :

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

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

  3. Le navigateur Web appelle l'URL.

  4. La page Connexion d'Oracle Identity Cloud Service s'affiche.

  5. L'utilisateur soumet ses données 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 s'affiche.

Cas d'utilisation #2 : Obtenir des détails sur l'utilisateur

Description de get-details-user.png ci-dessous
Description de l'illustration get-details-user.png

Le flux de données se déroule de la façon suivante :

  1. L'utilisateur demande la ressource /myProfile.

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

  3. Les données retournées à partir de la validation du jeton d'ID contiennent les détails de l'utilisateur dans le 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

La trousse SDK Node.js est une stratégie de passeport Node.js que vous ajoutez à votre dossier Node.js modules. Cette trousse SDK est également basée sur les promesses Node.js.

Toutes les dépendances de tierce partie dont la trousse SDK Node.js a besoin sont définies dans le fichier package.json de la trousse SDK dans le fichier zip de la trousse SDK Node.js que vous téléchargez à partir de la console Oracle Identity Cloud Service. Vous devez utiliser au moins ce jeu 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 mettent en oeuvre des routes d'URL sous la forme d'une fonction app.get() pour chaque URL.

La trousse SDK Node.js nécessite 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 ces informations : 

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;

Vous trouverez ci-dessous une brève explication de chaque attribut requis pour cette trousse SDK :

Nom Description
ClientId Valeur de l'ID client générée après l'enregistrement 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'enregistrement 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, le paramètre fictif %tenant% est remplacé par la valeur de l'attribut ClientTenant.
AudienceServiceUrl URL du nom de domaine 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 au nom de l'utilisateur Oracle Identity Cloud Service.

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

ConsoleLog Active le journal de la trousse SDK.
LogLevel Indique le niveau de journal de la trousse SDK.

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

L'application Node.js met en oeuvre la route de l'URL /oauth/oracle. Lorsqu'un utilisateur s'authentifie auprès d'Oracle Identity Cloud Service, le navigateur Web envoie une demande GET à cette URL. Cette route utilise la trousse 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 dans une variable, initialise un gestionnaire d'authentification et utilise la fonction IdcsAuthenticationManager.getAuthorizationCodeUrl() de la trousse SDK Node.js pour générer l'URL du 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 de générer 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 Après la connexion d'un utilisateur, 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 approuvée dans la console Identity Cloud Service. Voir Enregistrer l'application Node.js pour plus d'informations sur la spécification d'une URL de redirection pour l'application Web Node.js.
auth.oracle.scope Portée d'authentification OAuth ou OpenID Connect. Cette application nécessite 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. Dans cet exemple, la valeur de ce paramètre est 1234.
response_type Paramètre requis par le type d'octroi de code d'autorisation. Dans 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 rappel, que le développeur doit mettre en oeuvre. L'application Web Node.js utilise la route /callback pour traiter 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é en tant que cookie, qui est ensuite envoyé au navigateur Web pour une utilisation future.

La fonction IdcsAuthenticationManager.authorizationCode() de la trousse SDK Node.js utilise également Promesse (énoncé then-catch) pour définir le jeton d'accès en tant que témoin et pour rediriger le navigateur vers la page /auth.html.

La trousse SDK Node.js est basée sur le cadre 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 programme de traitement d'URL /auth et utiliser la méthode passport.authenticate() avec le nom de stratégie Oracle Identity Cloud Service comme 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');
});

Après 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 a 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 la route /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 programme de traitement de la route /myProfile utilise la fonction IdcsAuthenticationManager.validateIdToken() de la trousse SDK pour obtenir des informations sur l'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 déconnecter l'utilisateur de l'authentification unique entre l'application et Oracle Identity Cloud Service, l'application Web Node.js met en oeuvre la route /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);
    }
  })
});

Cette route invalide la session de l'application, supprime tout objet et témoin défini précédemment, puis redirige le navigateur Web de l'utilisateur vers l'URL de déconnexion d'Oracle Identity Cloud Service OAuth.