Téléchargement des produits


Version anglaise


 


Adélia fournit un module d'extension basé sur Pac4J permettant d'implémenter une sécurité JEE avancée (support d'"OpenID Connect" en implémentant l'"authorization code flow"). Ce module d'extension peut être utilisé aussi bien avec Adélia Web qu'avec Adélia Cloud. 

https://github.com/pac4j/jee-pac4j


Ce module est basé sur un ensemble de filtres dérivés de l'implémentation de base des filtres Pac4J et ajoutant une configuration et un comportement par défaut spécifique à Adélia.

Il propose également un login module spécifique pour Adélia Cloud permettant de déléguer la gestion des rôles (isUserInRole) à Pac4J.


Le fichier de configuration de l'extension (security.yml)

Ce fichier contient les paramètres de l'extension. Il est recherché par défaut dans le répertoire "WEB-INF/conf"; de l'application Web, mais peut être externalisé via la ressource JNDI "java:comp/env/url/adeliaSecurityConfig";.

wagonSecurity: 
  callbackUrl: https://domain.com/application/callback 
  accessTokenExpiryAdvance: 30 
corsAuthorizer: 
  allowedOrigins: "*" 
  allowedMethods: GET,POST,HEAD,OPTIONS,PUT,DELETE 
  # allowedHeaders: Content-Type,X-Requested-With,accept,Origin,Access-Control-Request-Method,Access-Control-Request-Headers,Authorization 
  # preflightMaxage: 1800  
authorizationGenerator: 
  className: com.hardis.adelia.jee.security.RoleGenerator 
  rolesClaim: resource_access.clientId.roles, realm_access.roles 
clientsProperties: 
  Oidc.client_name: clientName 
  oidc.id: clientId 
  oidc.secret: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx 
  oidc.discoveryUri: https://identity_provider.com/pathTo/.well-known/openid-configuration 
  oidc.useNonce: true 
  oidc.preferredJwsAlgorithm: RS256 
  oidc.scope: openid email profile 
  oidc.clientAuthenticationMethod: client_secret_post


Le fichier de configuration contient les sections suivantes :


La section "wagonSecurity"; contient les paramètres généraux du module :

  • callbackUrl est l'URL du callback à utiliser lorsque l'on active l'authentification OpenID. Il s'agit de l'URL absolue correspondant au CallbackFilter (voir plus bas).

=>> par exemple : https://domain.com/application/callback


  • accessTokenExpiryAdvance est le délai avant expiration utilisé pour déterminer si le token d'accès doit être renouvelé. La valeur par défaut est de 30 secondes.


=>> en mode OpenID connect, le filtre de sécurité Adélia "SecurityFilter"; va automatiquement mettre à jour les tokens d'accès. Le fournisseur d'identité utilisé doit supporter le "refresh token";. 




La section "authorizationGenerator"; permet de définir le paramétrage de la génération des rôles. Il s'agit d'une section optionnelle.

Le générateur d'autorisation est automatiquement appelé à la fin de l'authentification. Il a pour but d'extraire des informations d'identité la liste des rôles de sécurité associés à l'utilisateur connecté.


Adélia fournit une implémentation par défaut (com.hardis.adelia.jee.security.RoleGenerator) qui permet d'extraire une liste de rôles d'un "claim"; des informations utilisateur. Il est possible de fournir une implémentation personnalisée.


L'implémentation Adélia permet également de charger le nom d'utilisateur (*USER) depuis un claim spécifique (par défaut avec OpenID, le nom d'utilisateur est extrait du claim "preferred_username" du profil).


Les paramètres sont :

  • className est le nom de la classe à utiliser. Celle-ci doit implémenter l'interface "org.pac4j.core.authorization.generator.AuthorizationGenerator"; de Pac4J. La valeur par défaut est "com.hardis.adelia.cloud.security.ext.RoleGenerator";.
  • userNameClaim est le nom du claim contenant le nom de l'utilisateur (ex: userNameClaim: email). Si ce paramètre n'est pas spécifié c'est le "preferred_username" du profil qui sera utilisé, ou en l'absence d'information de profil l'ID de l'utilisateur.
  • rolesClaim est le nom du claim contenant la liste des rôles (dans le cas de la classe d'extension par défaut). Vous pouvez spécifier un nom qualifié, et consolider la lecture de plusieurs claims en séparant les noms par des virgules.
  • parseAccessToken permet de chercher les rôles et/ou le nom de l'utilisateur dans le token d'accès (si OpenID). Par défaut (false), seuls le token identifiant et les informations utilisateur sont pris en compte par le générateur de rôles.

Une implémentation utilisateur est libre de définir d'autres paramètres. Par exemple, l'implémentation suivante (className = com.test.CustomRoleGenerator) associe le rôle "wagon-administrator"; à un profil configuré.


package com.test; 
 
import org.pac4j.core.authorization.generator.AuthorizationGenerator; 
import org.pac4j.core.context.WebContext; 
import org.pac4j.core.profile.CommonProfile; 
 
import com.hardis.adelia.jee.security.SecurityConfig; 
  
public class CustomRoleGenerator<U extends CommonProfile> implements AuthorizationGenerator<U> { 
    private String adminProfile; 
     
    public CustomRoleGenerator() { 
        adminProfile = SecurityConfig.getString(SecurityConfig.AUTHORIZATION_GENERATOR, "adminProfile", "admin"); 
    } 
     
    @Override 
    public U generate(WebContext context, U profile) { 
        for (String role: computeRoles(context, profile)) { 
            profile.addRole(role); 
        } 
     
        return profile; 
    } 
     
    private String[] computeRoles(WebContext context, U profile) { 
        return (profile.getUsername().equals(adminProfile))? new String[] { "wagon-administrator", "user" } : new String[] { "user" };   
    } 
}


La section "corsAuthorizer"; permet d'activer un filtre CORS intégré. Il s'agit d'une section optionnelle.

Le filtre CORS sera activé si la section est présente dans le fichier de configuration.

Les paramètres sont :

  • allowedOrigins définit la liste des origines qui sont autorisées à accéder à la ressource. "*" permet d'accepter toutes les origines. La valeur par défaut est "*";.
  • allowedMethods définit la liste des méthodes HTTP autorisées, séparées par des virgules. Les méthodes reconnues sont GET, POST, HEAD, TRACE, PUT, DELETE, OPTIONS et PATCH. Non défini par défaut.
  • allowedHeaders définit la liste des headers autorisés dans les requêtes. Non défini par défaut.
  • exposedHeaders définit la liste des headers exposés dans les réponses au navigateur. Non défini par défaut.
  • allowCredentials permet d'autoriser ou non la propagation des cookies, vecteurs d'accréditation et certificats SSL. Vrai par défaut.


La section "clientsProperties"; contient les propriétés des clients Pac4J. La configuration des clients est instanciée en utilisant les mécanismes standard de Pac4J ("PropertiesConfigFactory";).

Le fichier exemple ci-dessus définit une configuration minimale de l'extension de sécurité pour une authentification Open ID connect.


  • oidc.clientName est une extension Adélia permettant de forcer le nom du client Pac4J au lieu d'utiliser un nom généré (celui-ci apparaissant dans l'url du callback qui peut être validée par le serveur d'identité).
  • oidc.id est l'identifiant de votre application enregistré auprès de votre fournisseur. Il vous est fourni par le fournisseur d'identité.
  • oidc.secret est le secret associé à votre application. Il vous est fourni par le fournisseur d'identité.
  • oidc.discoveryUri est l'URL du endpoint de configuration du fournisseur d'identité.
  • oidc.clientAuthenticationMethod permet de forcer la méthode d'authentification avec le serveur (valeurs possibles "client_secret_post";, "client_secret_basic"; ou "none";).


Remarque : par défaut, le client OpenID utilise le mode de connexion "authorisation code flow";. Il est possible d'utiliser le mode "implicit flow"; en ajoutant les propriétés suivantes :

    • oidc.responseType indique le type de réponse demandé au provider. Pour l'implicit flow, indiquez la valeur "id_token"; ou "id_token token"; ("code"; par défaut).
    • oidc.responseMode indique le mode de transfert des résultats. Pour l'implicit flow, indiquez la valeur "form_post"; (non renseigné par défaut).


La référence complète des paramètres de la "PropertiesConfigFactory"; peut être trouvée ici (classée par type de client) : https://www.pac4j.org/docs/config.html.

Remarque : l'extension Adélia ne supporte pas le multi-profile dans Pac4J. La configuration de plusieurs clients par les propriétés n'est pas supportée.


Le filtre com.hardis.adelia.jee.security.filter.SecurityFilter

Ce filtre étend le filtre "SecurityFilter"; de Pac4J. La configuration de ce filtre est obligatoire si vous utilisez l'extension.

https://github.com/pac4j/jee-pac4j/wiki/Security-configuration


La version Adélia de ce filtre ajoute les fonctionnalités suivantes (en utilisation conjointe avec Open ID) :

Rafraîchissement automatique du token d'accès si supporté par le fournisseur d'identité.

Support du login module WagonLoginModule pour la gestion des rôles en Adélia Cloud.


Le filtre déclare un paramètre supplémentaire par rapport à l'original :

  • excludeUrlPattern permet de déclarer une expression régulière permettant d'indiquer des URL à exclure du traitement, et qui ne seront donc pas sécurisées. Attention, contrairement au paramètre "url-pattern" du filter-mapping, il s'agit d'une expression régulière complexe. De plus, celle-ci est évaluée en tenant compte des paramètres de la requête (si l'URL est "http://serveur/application/logout.jsp?sessionId=xxxxx", l'expression régulière est évaluée sur "/logout.jsp?sessionId=xxxxx", alors que l'url-pattern du filter-mapping ne tient pas compte des paramètres et est évalué sur "/logout.jsp").

    L'exemple ci-dessous permet d'exclure /logout.jsp (qui peut prendre des paramètres, d'où le ".*", les scripts et ressources statiques (/js/* et /favicon.ico, potentiellement chargées par logout.jsp), et les URL générées par la fonction VaToolBxCloudDownloadFile (ce qui permet de les utiliser hors du contexte navigateur, dans un gestionnaire de téléchargement par exemple).


Déclaration du filtre dans "web.xml"; :

 <filter> 
        <filter-name>SecurityFilter</filter-name> 
        <filter-class>com.hardis.adelia.jee.security.filter.SecurityFilter</filter-class>
        <init-param>
            <param-name>excludeUrlPattern</param-name>
            <param-value>/logout.jsp.*|/js/.*|/favicon.ico|/WagonServlet.*action=DOWNLOAD.*</param-value>
        </init-param>
 </filter> 
    ... 
    <filter-mapping> 
        <filter-name>SecurityFilter</filter-name> 
        <url-pattern>/*</url-pattern> 
    </filter-mapping>


Utilisation avec Adélia Cloud :


Avec Adélia Cloud, il est conseillé par défaut de sécuriser l'ensemble de l'application (<url-pattern>/* </url-pattern>) dans la configuration du filtre. Si toutefois vous ne souhaitez sécuriser que l'application cloud elle-même mais pas les ressources (par exemple pour permettre la redirection vers "logout.jsp"; dans le LogoutFilter, sans générer une nouvelle demande d'authentification après la déconnexion), vous pouvez utiliser le paramètre "excludeUrlPattern" du filtre comme décrit au-dessus, ou bien le paramétrage suivant pour sécuriser uniquement les points d'entrée critiques de l'application :


  <filter-mapping> 
        <filter-name>SecurityFilter</filter-name> 
        <url-pattern>/index.jsp</url-pattern> 
        <url-pattern>/WagonServlet/*</url-pattern> 
        <url-pattern>/WagonSyncServlet/*</url-pattern> 
        <url-pattern>/WagonWS/*</url-pattern> 
   </filter-mapping>


Le filtre com.hardis.adelia.jee.security.filter.CallbackFilter

Ce filtre étend le filtre "CallbackFilter"; de Pac4J pour charger la configuration Adélia uniquement. Le paramétrage est identique au filtre original.

https://github.com/pac4j/jee-pac4j/wiki/Callback-configuration


La configuration de ce filtre est nécessaire uniquement dans le cas de l'utilisation d'"Open ID". S'il est configuré, il doit être déclaré en premier dans la liste des filtres à l'exécution (filter-mapping dans web.xml). Il doit impérativement s'exécuter avant le SecurityFilter.


  <filter> 
        <filter-name>CallbackFilter</filter-name> 
        <filter-class>com.hardis.adelia.jee.security.filter.CallbackFilter</filter-class> 
        <init-param> 
            <param-name>renewSession</param-name> 
            <param-value>false</param-value> 
        </init-param> 
   </filter> 
    ... 
    <filter-mapping> 
        <filter-name>CallbackFilter</filter-name> 
        <url-pattern>/callback</url-pattern> 
    </filter-mapping>


Le filtre com.hardis.adelia.jee.security.filter.LogoutFilter

Ce filtre étend le filtre "LogoutFilter"; de Pac4J pour déclencher le logout à la fermeture de la dernière session Adélia Cloud liée à la session Java EE en cours.

https://github.com/pac4j/jee-pac4j/wiki/Logout-configuration


La configuration de ce filtre est optionnelle, il permet de déclencher par une requête HTTP l'invalidation de la session JEE et optionnellement de la session OP (dans le cas d'Open ID, de déconnecter l'utilisateur au niveau du fournisseur d'identité).

Le filtre déclare un paramètre supplémentaire par rapport à l'original :

  • preventCloudLogout (positionné à "true" par défaut) empêche le logout si plusieurs sessions cloud sont associées à la session JEE courante (plusieurs onglets du navigateur ouverts sur l'application). Dans ce cas le logout ne sera effectif qu'à la fermeture de la dernière session cloud.


Déclaration du filtre dans web.xml :

  <filter> 
        <filter-name>LogoutFilter</filter-name> 
        <filter-class>com.hardis.adelia.jee.security.filter.LogoutFilter</filter-class> 
        <init-param> 
            <param-name>centralLogout</param-name> 
            <param-value>true</param-value> 
        </init-param> 
        ... 
   </filter> 
    ... 
    <filter-mapping> 
        <filter-name>LogoutFilter</filter-name> 
        <url-pattern>/jee/logout</url-pattern> 
    </filter-mapping> 
    ...


Utilisation avec Adélia Cloud : 

Pour appeler automatiquement le filtre lorsque la session cloud est fermée par l'utilisateur, vous devez simplement indiquer l'URL sur laquelle le filtre est configuré (dans l'exemple /jee/logout) dans la configuration du paramètre "logoutUrl"; du desktop wagon :



  <desktopApplication name="default" ... logoutURL="jee/logout" ... />



Installation

L'extension n'est pas livrée avec Adélia mais accessible par les outils d'intégration continue via le référentiel Hardis. Veuillez vous référencer à la documentation du "Build Adélia"; (build par domaines ou build par composants) pour les paramètres de configuration du référentiel.

Vous devez ajouter l'artéfact "adelia-jee-security" du groupe "com.hardis.adelia"; dans vos dépendances.

Par exemple, dans un template gradle pour Adélia Cloud, vous devez rajouter l'instruction suivante à la section "dependencies"; de build.gradle :


  runtime group:'com.hardis.adelia',name:'adelia-jee-security',version:'${project.ext.adeliaVersion}'


Attention, l'extension ramène en dépendances les modules de base de Pac4J ainsi que l'extension OpenID. Si vous souhaitez utiliser d'autres extensions de sécurité, vous devez les référencer explicitement.

Par exemple, pour utiliser le module LDAP avec une authentification par formulaire, vous avez besoin de "pac4j-ldap"; et "pac4j-http";. Actuellement, la version de Pac4J utilisée est la version 3.8.0 :


runtime group:'org.pac4j',name:'pac4j-ldap',version:'3.8.0' 
runtime group:'org.pac4j',name:'pac4j-http',version:'3.8.0'

↑ Haut de page




  • Aucune étiquette