1. Authentification d'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 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 Java

  • Cas d'utilisation d'un kit SDK avec une application Java pour l'authentification auprès d'Oracle Identity Cloud Service

  • Méthodes et fonctions du kit SDK Java

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 Java. 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 Java 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 Java à 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 Java

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

Le fichier ZIP du kit SDK Java contient les bibliothèques tierces requises suivantes, nécessaires au kit SDK. Vous pouvez les charger dans votre application.

  • Programme d'assistance ASM Minidev 1.0.2

  • Collections Apache Commons 4.1

  • Langue Apache Commons 3.7

  • Analyseur JSON petit et rapide 2.3

  • Nimbus LangTag 1.4.3

  • Nimbus JOSE+JWT 5.14

  • Kit SDK OAuth 2.0 avec extensions OpenID Connect 5.30

Oracle fournit un exemple d'application Web Java pour montrer comment utiliser le kit 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 du kit SDK Java. L'application utilise Maven pour obtenir toutes les bibliothèques et générer un fichier de ressource d'application Web (WAR).

Le kit SDK Java requiert une instance d'objet HashMap chargée avec les informations de connexion Oracle Identity Cloud Service. L'application Web Java implémente 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;
    }

Voici une brève explication de chaque attribut requis pour ce kit 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'inscription 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'inscription 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 de nom de domaine qualifié 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 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 également le kit 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 SDK.
Constants.LOG_LEVEL 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 Web Java implémente la classe AuthServlet, qui met en correspondance l'URL /auth. Lorsqu'un utilisateur décide de s'authentifier auprès d'Oracle Identity Cloud Service, le navigateur Web envoie une demande à cette URL. La classe AuthServlet initialise l'objet Authentication Manager, utilise le kit SDK Java pour générer l'URL de 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 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 Java, reportez-vous à Inscription de l'application Java.
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 Java 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 Java utilise CallbackServlet pour gérer 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() du kit 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() renvoient une instance de l'objet IdToken qui contient 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. Les valeurs de jeton d'accès et d'ID, ainsi que certaines informations 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 appelé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 de jeton d'ID 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'accès avec connexion unique entre l'application et Oracle Identity Cloud Service, l'application Web Java implémente LogoutServlet, qui met en correspondance 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.