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

En savoir plus sur les flux d'authentification 3D

Oracle Identity Cloud Service prend en charge le flux d'authentification à trois facteurs pour le 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 le SDK échange pour un jeton d'accès utilisateur. L'application Web Node.js utilise ce jeton d'accès pour accorder aux utilisateurs un accès aux ressources protégées de l'application. Le flux à trois facteurs utilise le type d'octroi de code d'autorisation.

Pour une sécurité accrue, Oracle recommande d'utiliser le flux à trois facteurs afin d'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 authentifier à nouveau.

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

L'application Web Node.js implémente deux cas d'emploi : un pour l'authentification des utilisateurs et l'autre pour l'accès aux 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'emploi n ° 1 : authentifier un utilisateur

Description de l'image authenticate-user.png

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

L'utilisateur demande une ressource protégée.
Le module d'authentification utilise le kit SDK pour générer une URL request-authorization-code pour Oracle Identity Cloud Service et envoyer cette URL en tant que réponse de réacheminement au navigateur Web.
Le navigateur Web appelle l'URL.
La page Connexion à Oracle Identity Cloud Service apparaît.
L'utilisateur soumet ses informations d'identification de connexion à Oracle Identity Cloud Service.
Une fois que l'utilisateur s'est connecté, Oracle Identity Cloud Service crée une session pour l'utilisateur et émet un code d'autorisation.
L'application Web effectue un appel back-end (ou de serveur à serveur) pour échanger le code d'autorisation d'un jeton d'accès utilisateur.
Oracle Identity Cloud Service émet le jeton d'accès.
Une session est établie et l'utilisateur est redirigé vers la page d'accueil.
La page d'accueil de l'application Web apparaît.

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

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

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

L'utilisateur demande la ressource /myProfile.
L'application Web appelle Oracle Identity Cloud Service à l'aide du kit SDK, qui utilise le jeton d'accès stocké dans la session utilisateur comme paramètre.
Les détails de l'utilisateur sont envoyés à l'application Web en tant qu'objet JSON.
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 nécessaires au kit SDK Node.js sont définies dans le fichier package.json du kit SDK. 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": "^7.1.9",
    "jwk-to-pem": "^1.2.6",
    "jws": "^3.1.4",
    "lru": "^3.1.0",
    "passport": "^0.3.2",
    "promise": "^7.1.1",
    "querystring": "^0.2.0",
    "request": "^2.79.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 acheminements d'URL sous la forme d'une fonction app.get() pour chaque URL.

Le 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 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'
    }
};
 
module.exports = ids;

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

Nom	Description
`ClientId`	Valeur de l'ID client généré après l'inscription de l'application Web Node.js dans la console Identity Cloud Service.
`ClientSecret`	Valeur de la clé secrète du client générée après l'inscription de l'application Web Node.js dans la console Identity Cloud Service.
`ClientTenant`	Préfixe de domaine de votre instance Oracle Identity Cloud Service. Ce préfixe est généralement semblable à `idcs-abcd1234`.
`IDCSHost`	Suffixe de domaine de votre instance Oracle Identity Cloud Service. Au moment 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 l'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`.

L'application utilise les attributs logoutSufix et redirectURL. Le kit SDK ne les exige pas.

L'application Node.js implémente l'acheminement d'URL /oauth/oracle. Lorsqu'un utilisateur décide de s'authentifier auprès de Oracle Identity Cloud Service, le navigateur Web envoie une demande à cette URL. Cet acheminement utilise le kit SDK pour générer l'URL d'autorisation de 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() du kit SDK Node.js pour générer l'URL du code d'autorisation. Cette fonction utilise la promesse pour rediriger le navigateur Web de l'utilisateur lorsque l'URL du code d'autorisation est générée ou pour afficher une erreur dans le navigateur.

Les paramètres suivants permettent de générer l'URL de code d'autorisation :

Nom	Description
`auth.oracle.redirectURL`	Une fois l'utilisateur connecté, Oracle Identity Cloud Service redirige le navigateur Web de l'utilisateur vers cette URL. Cette URL doit correspondre à celle que vous configurerez pour l'application sécurisée dans la console Identity Cloud Service. Pour plus d'informations sur la spécification d'une URL de réacheminement pour l'application Web Node.js, reportez-vous à Inscrire l'application Node.js.
`auth.oracle.scope`	Portée d'authentification de OAuth ou de OpenID. 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 de 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 l'acheminement /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 Token Value.
            res.cookie(config.IDCS_COOKIE_NAME, 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 en vue d'une utilisation ultérieure.

La fonction IdcsAuthenticationManager.authorizationCode() du kit SDK Node.js utilise également promise (instruction then-catch) pour définir le jeton d'accès comme 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, vous devez 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 la session de l'application créée par la méthode passport.authenticate(), la fonction redirige le navigateur Web de l'utilisateur vers une URL protégée de l'application /home. En plus de /home, l'application Web Node.js a trois autres applications URLs protégées : /appDetails, /userInfo et /myProfile.

Chaque 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 fonctions URLs.

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

L'application Node.js gère l'acheminement /myProfile et obtient les informations définies dans la session par la méthode passport.authenticate(), comme suit :

app.get("/myProfile", ensureAuthenticated, function(req,res){
   //User Manager loaded with the configurations
   var um = new IdcsUserManager(auth.oracle);
   //Using the user id in the request attribute to render the user json in the screen.
   um.getUser(req.user.id)
      .then(function(user){
         res.render('myProfile', {
         layout: 'privateLayout',
         title: 'My Profile',
         user: req.user,
         userInfo: JSON.stringify(user, null, 2)
         });
      }).catch(function(err1){
         res.end(err1);
      })
});

Après l'initialisation de l'objet UserManager, le gestionnaire de l'acheminement /myProfile utilise la fonction IdcsUserManager.getUser() du SDK pour obtenir un objet JSON représentant le profil utilisateur. L'application envoie l'objet JSON au fichier myProfile.handlebars pour l'affichage dans le navigateur Web.

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

app.get('/logout', function(req, res){
   req.logout();
   res.clearCookie();
   res.redirect(auth.oracle.IDCSHost + auth.oracle.logoutSufix);
});

Cet acheminement invalide la session de l'application, enlève tous les cookies définis précédemment, puis redirige le navigateur Web de l'utilisateur vers l'URL de déconnexion de Oracle Identity Cloud ServiceOAuth. Cette URL est configurée dans l'objet de configuration JSON.