1. Authentifier une application Java avec Oracle Identity Cloud Service
  2. En savoir plus sur l'authentification entre les applications Java et Oracle Identity Cloud Service

En savoir plus sur l'authentification entre les applications Java et Oracle Identity Cloud Service

Vous êtes prêt à en apprendre davantage sur l'authentification entre les applications Web Java 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 Java

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

  • Méthodes et fonctions de la trousse SDK Java

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 Java. 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 Java 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 Java à 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 principaux cas d'utilisation d'une trousse SDK avec une application Java

L'application Web Java implémente deux cas d'utilisation : 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'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 Java est un fichier JAR que vous chargez en tant que bibliothèque d'applications Web. Ce fichier JAR nécessite les bibliothèques de tierce partie suivantes que vous devez également charger dans la bibliothèque :

Le fichier zip de la trousse SDK Java contient les bibliothèques de tierce partie requises suivantes nécessaires pour la trousse SDK. Vous pouvez les charger dans votre application.

  • Application d'aide ASM - Version 1.0.2

  • Collections Apache Commons 4.1

  • Apache Commons Lang 3.7

  • Analyseur JSON petit et rapide 2.3

  • Nimbus LangTag 1.4.3

  • Nimbus JOSE+JWT 5.14

  • OAuth Trousse SDK 2.0 avec extensions OpenID Connect 5.30

Oracle fournit un exemple d'application Web Java pour démontrer comment utiliser la trousse SDK Java. Cette application a été créée à l'aide de la technologie Servlet pour simplifier l'expérience d'apprentissage et comprendre le fonctionnement de la trousse SDK Java. L'application utilise Maven pour obtenir toutes les bibliothèques et générer un fichier WAR (Web Application Resource).

La trousse SDK Java nécessite une instance d'objet HashMap chargée avec les informations de connexion à Oracle Identity Cloud Service. L'application Web Java met en oeuvre cette instance HashMap en tant qu'attribut de classe dans la classe ConnectionOptions.java. 

//Instance of a HashMap.
    private Map<String,Object> options = new HashMap<>();
  
public ConnectionOptions(){
        this.options = new HashMap<>();
}
  
public Map<String,Object> getOptions(){
        //Adding Oracle Identity Cloud Service connection parameters to the HashMap instance.
        this.options.put(IDCSTokenAssertionConfiguration.IDCS_HOST, "identity.oraclecloud.com");
        this.options.put(IDCSTokenAssertionConfiguration.IDCS_PORT, "443");
        this.options.put(IDCSTokenAssertionConfiguration.IDCS_CLIENT_ID, "123456789abcdefghij");
        this.options.put(IDCSTokenAssertionConfiguration.IDCS_CLIENT_SECRET, "abcde-12345-zyxvu-98765-qwerty");
        this.options.put(IDCSTokenAssertionConfiguration.IDCS_CLIENT_TENANT, "idcs-abcd1234");
        this.options.put(Constants.AUDIENCE_SERVICE_URL, "https://idcs-abcd1234.identity.oraclecloud.com");
        this.options.put(Constants.TOKEN_ISSUER, "https://identity.oraclecloud.com/");
        this.options.put(Constants.TOKEN_CLAIM_SCOPE, "urn:opc:idm:t.user.me openid");
        this.options.put("SSLEnabled", "true");
        this.options.put("redirectURL", "http://localhost:8080/callback");
        this.options.put("logoutSufix", "/oauth2/v1/userlogout");
        this.options.put(Constants.CONSOLE_LOG, "True");
        this.options.put(Constants.LOG_LEVEL, "DEBUG");
        return this.options;
    }

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

Nom Description
IDCSTokenAssertionConfiguration.IDCS_HOST Suffixe de domaine de votre instance Oracle Identity Cloud Service.
IDCSTokenAssertionConfiguration.IDCS_PORT Numéro de port HTTPS réservé à votre instance Oracle Identity Cloud Service (généralement 443).
IDCSTokenAssertionConfiguration.IDCS_CLIENT_ID Valeur de l'ID client générée après l'enregistrement de l'application Web Java dans la console Identity Cloud Service.
IDCSTokenAssertionConfiguration.IDCS_CLIENT_SECRET Valeur de la clé secrète client générée après l'enregistrement de l'application Web Java dans la console Identity Cloud Service.
IDCSTokenAssertionConfiguration.IDCS_CLIENT_TENANT Préfixe de domaine de votre instance Oracle Identity Cloud Service. Ce préfixe est généralement une valeur similaire à idcs-abcd1234.
Constants.AUDIENCE_SERVICE_URL URL du nom de domaine complet de votre instance Oracle Identity Cloud Service.
Constants.TOKEN_ISSUER Pour cet attribut, Oracle recommande de conserver la valeur https://identity.oraclecloud.com.
Constants.TOKEN_CLAIM_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 également la trousse SDK pour obtenir des détails sur l'utilisateur, la portée est urn:opc:idm:t.user.me openid.

SSLEnabled Indique si Oracle Identity Cloud Service répond aux demandes HTTPS ou HTTP. Pour cet attribut, Oracle recommande de conserver la valeur true.
Constants.CONSOLE_LOG Active le journal de la trousse SDK.
Constants.LOG_LEVEL 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 Web Java met en oeuvre la classe AuthServlet, qui mappe l'URL /auth. Lorsqu'un utilisateur décide de s'authentifier auprès d'Oracle Identity Cloud Service, le navigateur Web fait une demande à cette URL. La classe AuthServlet initialise l'objet Authentication Manager, utilise la trousse SDK Java pour générer l'URL du code d'autorisation d'Oracle Identity Cloud Service, puis redirige le navigateur Web vers cette URL. 

public class AuthServlet extends HttpServlet {
    protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //Loading the configurations
        Map<String, Object> options = new ConnectionOptions().getOptions();
        //Configuration object instance with the parameters loaded.
        IDCSTokenAssertionConfiguration config = new IDCSTokenAssertionConfiguration(options);
	String redirectUrl = (String)options.get("redirectURL");
        String scope = (String)options.get(Constants.TOKEN_CLAIM_SCOPE);
        //Authentication Manager loaded with the configurations.
        AuthenticationManager am = AuthenticationManagerFactory.getInstance(config);
        //Using Authentication Manager to generate the Authorization Code URL, passing the
        //application's callback URL as parameter, along with code value and code parameter.
        String authzURL = am.getAuthorizationCodeUrl(redirectUrl, scope, "1234", "code");
        //Redirecting the browser to the Oracle Identity Cloud Service Authorization URL.
        response.sendRedirect(authzURL);
    }
}

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

Nom Description
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 Java pour plus d'informations sur la spécification d'une URL de redirection pour l'application Web Java.
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 Java 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 Java utilise CallbackServlet pour traiter cette demande. 

public class CallbackServlet extends HttpServlet {
    protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //Loading the configurations
        Map<String, Object> options = new ConnectionOptions().getOptions();
        //After Oracle Identity Cloud Service authenticates the user, the browser is redirected to the
        //callback URL, implemented as a Servlet.
        IDCSTokenAssertionConfiguration config = new IDCSTokenAssertionConfiguration(options);
        //Authentication Manager loaded with the configurations.
        AuthenticationManager am = AuthenticationManagerFactory.getInstance(config);
        //Getting the authorization code from the "code" parameter
        String authzCode = request.getParameter("code");
        //Using the Authentication Manager to exchange the Authorization Code to an Access Token.
        AuthenticationResult ar = am.authorizationCode(authzCode);
        //Getting the Access Token object and its String value.
        AccessToken access_token = ar.getToken(OAuthToken.TokenType.ACCESS_TOKEN);
        String access_token_string = access_token.getToken();
        //Getting the ID Token object and its String value.
        IdToken id_token = ar.getToken(OAuthToken.TokenType.ID_TOKEN);
        String id_token_string = id_token.getToken();
        //Validating both Tokens to acquire information for User such as UserID, 
        //DisplayName, list of groups and AppRoles assigned to the user.
        IdToken id_token_validated = am.validateIdToken(id_token_string);
        //Storing information into the HTTP Session.
        HttpSession session=request.getSession();
        session.setAttribute("access_token", access_token_string);
        session.setAttribute("id_token", id_token_string);
        session.setAttribute("userId", id_token_validated.getUserId());
        session.setAttribute("displayName", id_token_validated.getDisplayName());
	//Forwarding the request to the Home page.
        request.getRequestDispatcher("private/home.jsp").forward(request, response);
    }
}

L'application demande le paramètre de code d'autorisation et l'utilise pour appeler la méthode AuthenticationManager.authorizationCode() de la trousse SDK Java afin de demander à la fois un jeton d'accès et un jeton d'ID. Le servlet utilise ensuite l'instance AuthenticationManager pour valider le jeton d'ID. Les méthodes AuthenticationManager.validateIdToken() retournent une instance de l'objet IdToken qui contient 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. Les valeurs de jeton d'accès et de jeton d'ID, ainsi que certaines informations sur l'utilisateur, sont stockées dans l'objet de session HTTP afin que la demande puisse être transmise à une URL protégée au sein de l'application nommée /private/home.jsp. En plus de /private/home.jsp, l'application Web Java a une autre URL protégée : /private/myProfile.jsp.

La page myProfile.jsp utilise l'exemple de code suivant pour obtenir plus d'informations sur l'utilisateur connecté à Oracle Identity Cloud Service : 


<%if(session.getAttribute("access_token")==null) response.sendRedirect("/login.html");%>
<!DOCTYPE html>
<%
/**
 * The /private/myProfile.jsp page accesses the user's access token previously set in the session, 
 * calls the getAuthenticatedUser method to retrieve the user's information, and then formats it as HTML.
 * @author felippe.oliveira@oracle.com
 * @Copyright Oracle
*/
  java.util.Map<String, Object> options = new sampleapp.util.ConnectionOptions().getOptions();
  //Configuration object instance with the parameters loaded.
  oracle.security.jps.idcsbinding.shared.IDCSTokenAssertionConfiguration configuration = new oracle.security.jps.idcsbinding.shared.IDCSTokenAssertionConfiguration(options);
  oracle.security.jps.idcsbinding.shared.AuthenticationManager am = oracle.security.jps.idcsbinding.shared.AuthenticationManagerFactory.getInstance(configuration);
  
  //Getting the Access Token and the Id Token from the session object
  String access_token_string = (String)session.getAttribute("access_token");
  String id_token_string = (String)session.getAttribute("id_token");

  //Validating the ID Token to get user information, groups and app roles associated with the user.
  oracle.security.jps.idcsbinding.api.AccessToken access_token_validated = am.validateAccessToken(access_token_string);
  oracle.security.jps.idcsbinding.api.IdToken id_token_validated = am.validateIdToken(id_token_string);
%>

La page /private/myProfile.jsp accède à la valeur du jeton d'ID qui a été définie dans la session, appelle la méthode AuthenticationManager.validateIdToken() pour extraire les informations de l'utilisateur, puis la présente en tant que contenu HTML. 


<p><b>Information from the Identity Token:</b></p><p><%
out.println("DisplayName = "+ id_token_validated.getDisplayName() +"<br>");
out.println("IdentityDomain = "+ id_token_validated.getIdentityDomain() +"<br>");
out.println("UserName = "+ id_token_validated.getUserName()+"<br>");
out.println("UserId = "+ id_token_validated.getUserId()+"<br>");
out.println("Issuer = "+ id_token_validated.getIssuer()+"<br>");

java.util.List<oracle.security.jps.idcsbinding.api.IDCSAppRole> appRoles = id_token_validated.getAppRoles();
if(!appRoles.isEmpty()){
   out.println("App Roles:<br>");
   for(oracle.security.jps.idcsbinding.api.IDCSAppRole appRole: appRoles){
      out.println("&nbsp;appRole = "+ appRole.getName() +"<br>");
   }//for
}//if

java.util.List<oracle.security.jps.idcsbinding.api.IDCSGroup> groups = id_token_validated.getGroupMembership();
if(!groups.isEmpty()){
   out.println("Groups:<br>");
   for(oracle.security.jps.idcsbinding.api.IDCSGroup group: groups){
      out.println("&nbsp;group = "+ group.getName() +"<br>");
   }//for
}//if
%>
</p>
<p><b>Access Token:</b></p><p><%=access_token_string%></p>

Pour déconnecter l'utilisateur de l'authentification unique entre l'application et Oracle Identity Cloud Service, l'application Web Java met en oeuvre LogoutServlet, qui mappe l'URL /logout : 

public class LogoutServlet extends HttpServlet {
    protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        HttpSession session=request.getSession();
        String id_token = (String)session.getAttribute("id_token");
        session.invalidate();
        Map options = new ConnectionOptions().getOptions();
        String logoutURL = (String)options.get(Constants.AUDIENCE_SERVICE_URL) + (String)options.get("logoutSufix") +"?post_logout_redirect_uri=http%3A//localhost%3A8080&id_token_hint="+ id_token;
        response.sendRedirect(logoutURL);
    }
}

Ce servlet invalide la session de l'application, puis redirige le navigateur Web de l'utilisateur vers l'URL de déconnexion OAuth d'Oracle Identity Cloud Service.