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 à vous familiariser avec l'authentification entre les applications Web Java et Oracle Identity Cloud Service. Cela comprend les différences suivantes :

  • Flux d'authentification à trois facteurs pris en charge par Oracle Identity Cloud Service pour le SDK Java

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

  • Méthodes et fonctions du kit SDK Java

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 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 le SDK échange pour un jeton d'accès utilisateur. L'application Web Java 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 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 authentifier à nouveau.

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

L'application Web Java 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

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

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

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

  2. 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.

  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 que l'utilisateur s'est 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 de serveur à serveur) pour échanger le code d'autorisation d'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'emploi n ° 2 : obtenir des détails sur l'utilisateur

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

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

  1. L'utilisateur demande la ressource /myProfile.

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

  3. Les données renvoyées par la validation du 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 requiert 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 pour le kit SDK. Vous pouvez les charger dans votre application.

  • Helper ASM Minidev 1.0.2

  • Apache Commons Collections 4.1

  • Apache Commons Lang 3.7

  • 2.3 d'analyseur rapide et petit JSON

  • 1.4.3 LangTag Nimbus

  • JOSE+JWT 5.14 Nimbus

  • SDK OAuth 2.0 avec OpenID Connect Extensions 5.30

Oracle fournit un exemple d'application Web Java qui montre comment utiliser le kit SDK Java. Cette application a été conçue à l'aide de la technologie de 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 WAR (Web Application Resource).

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 obligatoire pour ce 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é 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 du 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 semblable à idcs-abcd1234.
Constants.AUDIENCE_SERVICE_URL URL de nom de domaine qualifié complet de l'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 la journalisation SDK.
Constants.LOG_LEVEL Indique le niveau de journalisation du kit SDK.

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

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 de 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 du code d'autorisation 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 permettent de générer l'URL de code d'autorisation :

Nom Description
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 Java, reportez-vous à Inscrire l'application Java.
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 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 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 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 SDK Java afin de demander à la fois un jeton d'accès et un jeton d'ID. Le servlet utilise alors l'instance AuthenticationManager pour valider le jeton d'ID. Les méthodes AuthenticationManager.validateIdToken() renvoient une instance de l'objet IdToken contenant des informations utilisateur telles que le nom d'affichage, l'ID utilisateur, ainsi que la liste des groupes et des rôles d'application affectés à l'utilisateur. Les valeurs de jeton d'accès et d'ID, et certaines informations utilisateur sont stockées dans l'objet de session HTTP pour que la demande puisse être transmise à une URL protégée dans l'application appelée /private/home.jsp. En plus de /private/home.jsp, l'application Web Java dispose d'une autre version protégée de URLs : /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 (SSO) entre l'application et Oracle Identity Cloud Service, l'application Web Java implémente LogoutServlet, qui met en correspondance l'URL de /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 de Oracle Identity Cloud Service.