Ce tutoriel et le projet d’exemple ont été testés avec les éléments suivants :

• Java 11

Obtenez vos clés d’application

Après votre inscription à Auth0, une nouvelle application a été créée pour vous, ou vous avez pu en créer une. Vous aurez besoin de quelques informations sur cette application pour communiquer avec Auth0. Vous pouvez obtenir ces détails dans la section Paramètres de l’application d’Auth0 Dashboard.

Les informations suivantes sont nécessaires :

• Domain (Domaine)

• Client ID (Identifiant client)

• Client Secret (Secret client)

Configurer les URL de rappel

Une URL de rappel est une URL dans votre application où Auth0 redirige l’utilisateur après qu’il se soit authentifié. La callbackc URL de votre application doit être ajoutée au champ URL de rappel autorisées dansples Paramètres de l’application. Si ce champ n’est pas défini, les utilisateurs ne pourront pas se connecter à l’application et obtiendront un message d’erreur.

Configuration des URL de déconnexion

Une URL de déconnexion est une URL de votre application à laquelle Auth0 peut retourner après la déconnexion de l’utilisateur du serveur d’autorisation. Elle est indiquée dans le paramètre de requête returnTo. L’URL de déconnexion de votre application doit être ajoutée au champ URL de déconnexion autorisées dans les paramètres de l’application. Si ce champ n’est pas défini, les utilisateurs ne pourront pas se déconnecter de l’application et obtiendront un message d’erreur.

Configurez les dépendances

Pour intégrer votre application Java EE avec Auth0, ajoutez les dépendances suivantes :

• javax.javaee-api : L’API Java EE 8 est nécessaire pour écrire des applications à l’aide de Java EE 8. L’implémentation réelle est fournie par le conteneur d’application : elle n’a donc pas besoin d’être incluse dans le fichier WAR.

• javax.security.entreprise : L’API de sécurité Java EE 8 permet de gérer les problèmes de sécurité dans une application EE. Comme la dépendance javax.javaee-api, l’implémentation est fournie par le conteneur d’application : elle n’est donc pas incluse dans le fichier WAR.

• auth0-java-mvc-commons : Le Kit de développement logiciel (SDK) Java MVC Auth0 vous permet d’utiliser Auth0 avec Java pour les applications Web MVC côté serveur. Il génère l’URL d’autorisation que votre application doit appeler pour authentifier un utilisateur à l’aide d’Auth0.

Si vous utilisez Maven, ajoutez les dépendances à votre pom.xml :

<!-- pom.xml -->
<dependency>
<groupId>com.auth0</groupId>
<artifactId>mvc-auth-commons</artifactId>
<version>[1.0, 2.0)</version>
</dependency>
<dependency>
<groupId>javax</groupId>
<artifactId>javaee-api</artifactId>
<version>8.0.1</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.security.enterprise</groupId>
<artifactId>javax.security.enterprise-api</artifactId>
<version>1.0</version>
<scope>provided</scope>
</dependency>

Si vous utilisez Gradle, ajoutez-les à votre build.gradle :

// build.gradle
providedCompile 'javax:javaee-api:8.0.1'
providedCompile 'javax.security.enterprise:javax.security.enterprise-api:1.0'
implementation 'com.auth0:mvc-auth-commons:1. '

Configurez votre application Java EE

Votre application Java EE a besoin de certaines informations pour authentifier les utilisateurs avec votre application Auth0. Le fichier descripteur de déploiement web.xml peut être utilisé pour stocker ces informations, bien que vous puissiez les stocker dans un autre emplacement sécurisé.

Ces informations seront utilisées pour configurer la bibliothèque auth0-java-mvc-commons afin de permettre aux utilisateurs de se connecter à votre application. Pour en savoir plus sur la bibliothèque, y compris ses différentes options de configuration, consultez le fichier README de la bibliothèque.

L’API de Java EE 8 Security a introduit l’interface HttpAuthenticationMechanism pour permettre aux applications d’obtenir les identifiants d’un utilisateur. Des implémentations par défaut existent pour l’authentification de base et l’authentification basée sur le formulaire, et il est facile de configurer une stratégie d’authentification personnalisée.

Pour s’authentifier avec Auth0, il faut fournir des implémentations personnalisées des interfaces suivantes :

• HttpAuthenticationMechanism : responsable de la gestion du flux d’authentification pour les utilisateurs qui reviennent d’Auth0. (JavaDoc).

• IdentityStore : responsable de la validation des identifiants de l’utilisateur (JavaDoc).

• CallerPrincipal : représente le principal de l’appelant de la requête HTTP en cours (JavaDoc).

• Credential : représente l’identifiant que l’appelant utilisera pour s’authentifier (JavaDoc).

Tout d’abord, mettez vos paramètres Auth0 à la disposition de l’application en créant un bean @ApplicationScoped pour récupérer les valeurs du contexte Web et les rendre disponibles via des getters (accesseurs).

Ensuite, créez un CallerPrincipal personnalisé qui représente l’appelant de la requête en cours :

// src/main/java/com/auth0/example/security/Auth0JwtPrincipal.java
public class Auth0JwtPrincipal extends CallerPrincipal {
private final DecodedJWT idToken;



Auth0JwtPrincipal(DecodedJWT idToken) {

    super(idToken.getClaim("name").asString());

    this.idToken = idToken;

}



public DecodedJWT getIdToken() {

    return this.idToken;

}

}

Vous pouvez maintenant mettre en œuvre un Credential personnalisé qui sera utilisé pour représenter les identifiants de l’utilisateur. Il contiendra des informations sur le principal :

// src/main/java/com/auth0/example/security/Auth0JwtCredential.java
class Auth0JwtCredential implements Credential {
private Auth0JwtPrincipal auth0JwtPrincipal;



Auth0JwtCredential(String token) {

    DecodedJWT decodedJWT = JWT.decode(token);

    this.auth0JwtPrincipal = new Auth0JwtPrincipal(decodedJWT);

}



Auth0JwtPrincipal getAuth0JwtPrincipal() {

    return auth0JwtPrincipal;

}

}

Vous avez maintenant défini les classes qui représentent le principal et l’identifiant d’un appelant. Ensuite, créez une implémentation personnalisée de IdentityStore. Cette classe sera chargée de valider les identifiants de l’utilisateur :

// src/main/java/com/auth0/example/security/Auth0JwtIdentityStore.java
@ApplicationScoped
public class Auth0JwtIdentityStore implements IdentityStore {
@Override

public CredentialValidationResult validate(final Credential credential) {

    CredentialValidationResult result = CredentialValidationResult.NOT_VALIDATED_RESULT;

    if (credential instanceof Auth0JwtCredential) {

        Auth0JwtCredential auth0JwtCredential = (Auth0JwtCredential) credential;

        result = new CredentialValidationResult(auth0JwtCredential.getAuth0JwtPrincipal());

    }

    return result;

}

}

Si le credential est un Auth0Credential, l’utilisateur appelant est authentifié et valide, et un CredentialValidationResult créé avec le credential est renvoyé pour indiquer le succès. S’il ne s’agit pas d’un Auth0Credential, un CredentialValidationResult.NOT_VALIDATED_RESULT est renvoyé.

Avant d’implémenter l’interface HttpAuthenticationMechanism qui utilisera tous ces collaborateurs, créez un bean qui fournira une instance configurée du AuthenticationController de la trousse SDK Auth0 Java MVC. Le AuthenticationController est utilisé pour construire l’URL d’autorisation où les utilisateurs se connecteront, et gérer l’échange de jetons pour authentifier les utilisateurs.

• Si votre application Auth0 est configurée pour utiliser l’algorithme de signature RS256 (par défaut lors de la création d’une nouvelle application Auth0), vous devez configurer un JwkProvider pour récupérer la clé publique utilisée pour vérifier la signature du jeton. Voir le référentiel jwks-rsa-java pour connaître les options de configuration supplémentaires.

• Si votre application Auth0 est configurée pour utiliser l’algorithme de signature HS256, il n’est pas nécessaire de configurer le JwkProvider.

L’exemple ci-dessous montre comment configurer le AuthenticationController pour l’utiliser avec l’algorithme de signature RS256 :

// src/main/java/com/auth0/example/security/Auth0AuthenticationProvider.java
@ApplicationScoped
public class Auth0AuthenticationProvider {
@Produces

public AuthenticationController authenticationController(Auth0AuthenticationConfig config) {

    JwkProvider jwkProvider = new JwkProviderBuilder(config.getDomain()).build();

    return AuthenticationController.newBuilder(config.getDomain(), config.getClientId(), config.getClientSecret())

            .withJwkProvider(jwkProvider)

            .build();

}

}

Enfin, mettez en œuvre un HttpAuthenticationMechanism personnalisé

// src/main/java/com/auth0/example/security/Auth0AuthenticationMechanism.java
@ApplicationScoped
@AutoApplySession
public class Auth0AuthenticationMechanism implements HttpAuthenticationMechanism {
private final AuthenticationController authenticationController;

private final IdentityStoreHandler identityStoreHandler;



@Inject

Auth0AuthenticationMechanism(AuthenticationController authenticationController, IdentityStoreHandler identityStoreHandler) {

    this.authenticationController = authenticationController;

    this.identityStoreHandler = identityStoreHandler;

}



@Override

public AuthenticationStatus validateRequest(HttpServletRequest httpServletRequest,

                                            HttpServletResponse httpServletResponse,

                                            HttpMessageContext httpMessageContext) throws AuthenticationException {



    // Exchange the code for the ID token, and notify container of result.

    if (isCallbackRequest(httpServletRequest)) {

        try {

            Tokens tokens = authenticationController.handle(httpServletRequest, httpServletResponse);

            Auth0JwtCredential auth0JwtCredential = new Auth0JwtCredential(tokens.getIdToken());

            CredentialValidationResult result = identityStoreHandler.validate(auth0JwtCredential);

            return httpMessageContext.notifyContainerAboutLogin(result);

        } catch (IdentityVerificationException e) {

            return httpMessageContext.responseUnauthorized();

        }

    }

    return httpMessageContext.doNothing();

}



private boolean isCallbackRequest(HttpServletRequest request) {

    return request.getRequestURI().equals("/callback") && request.getParameter("code") != null;

}

}

La classe a priorité sur la méthode validateRequest, qui est appelée à chaque demande adressée à notre application et qui est chargée de notifier au conteneur l’état de l’authentification.

Cet exemple utilise le flux de code d’autorisation pour échanger un code d’autorisation contre un jeton au cours du processus d’authentification. Si cette requête est adressée au point de terminaison /callback et contient le paramètre de requête code, elle effectue quelques opérations importantes :

• Elle appelle la méthode handle du AuthenticationController pour échanger le code d’autorisation contre un jeton d’ID et un jeton d’accès.

• Elle utilise le jeton d’ID pour créer un nouveau Auth0Credential.

• Elle appelle la méthode validate de l’implémentation personnalisée IdentityStore pour obtenir le résultat de la validation.

• Elle informe le conteneur de l’application de l’état de la connexion.

Si la ressource demandée n’est pas /callback, elle renvoie httpMessageContext.doNothing() pour permettre la poursuite du traitement de la demande. Vous verrez bientôt comment utiliser les informations d’authentification lors du déclenchement de l’authentification et de l’affichage des vues Web.

Enfin, notez que l’annotation @AutoApplySession a été ajoutée pour permettre au conteneur de créer une session pour l’utilisateur authentifié.

Pour permettre à un utilisateur de se connecter, créez un Servlet qui traitera les requêtes au chemin /login.

Le LoginController est responsable de rediriger la requête vers l’URL d’autorisation appropriée, où l’utilisateur peut s’authentifier avec Auth0. Il utilise le AuthenticationController du SDK Auth0 Java MVC pour construire le bon URL d’autorisation, en utilisant les valeurs de configuration injectées via Auth0AuthenticationConfig. Par défaut, cet exemple demande les permissions "openid profile email" pour permettre à l’application de récupérer les informations de profil de base auprès de l’utilisateur authentifié. Vous pouvez en savoir plus sur ces permissions dans la documentation OpenID Connect Scopes.

Une fois que l’utilisateur a entré ses identifiants et autorisé les permissions demandées, Auth0 enverra une requête au callbackUrl, incluant un paramètre de requête code qui peut être échangé contre un jeton d’ID et un jeton d’accès. Rappelons que le Auth0HttpAuthenticationMechanism créé ci-dessus gère cet échange afin qu’il puisse notifier le conteneur d’applications du statut d’authentification. Cela permet au Servlet qui gère les requêtes vers le chemin /callback de simplement transférer la requête à la ressource initialement demandée avant de se connecter, ou simplement de rediriger vers la page d’accueil :

// src/main/com/auth0/example/web/CallbackServlet.java
@WebServlet(urlPatterns = {"/callback"})
public class CallbackServlet extends HttpServlet {
@Override

public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {

    String referer = (String) request.getSession().getAttribute("Referer");

    String redirectTo = referer != null ? referer : "/";



    response.sendRedirect(redirectTo);

}

}

Vous pouvez utiliser Auth0JwtPrincipal pour obtenir des informations sur le profil de l’utilisateur authentifié. L’exemple de code HomeServlet.java montre comment utiliser les demandes sur le Jeton d’ID pour définir les données de profil comme attribut de requête.

Vous pouvez ensuite utiliser ces informations de profil dans votre vue pour afficher des informations sur l’utilisateur :

<!-- src/main/webapp/WEB-INF/jsp/fragments/navbar.jspf -->
<c:choose>
<c:when test="{empty profile}">
<li>
<form action="/login" method="GET">
<input type="submit" value="Login"/>
</form>
</li>
</c:when>
<c:otherwise>
<li>
<a href="#">
<!-- Profile image should be set to the profile picture from the id token -->
<img src="{profile.get('picture').asString()}" alt="Profile picture"/>
</a>
<div>
<!-- Show the user's full name from the id token here -->
<div>"{profile.get('name').asString()}"</div>
<a href="/profile">Profile</a>
<a href="/logout">Log out</a>
</div>
</li>
</c:otherwise>
</c:choose>

Pour déconnecter un utilisateur, vous devez effacer la session d’application et déconnecter l’utilisateur d’Auth0. Cette opération est gérée dans le LogoutServlet.

Commencez par effacer la session en appelant request.getSession().invalidate(). Créez ensuite l’URL de déconnexion, en veillant à inclure le paramètre de requête returnTo, vers lequel l’utilisateur sera redirigé après la déconnexion. Enfin, redirigez la réponse vers l’URL de déconnexion de l’application.

Pour construire et exécuter l’exemple, exécutez l’objectif Maven wildfly:run pour démarrer un serveur d’application WildFly intégré avec cette application déployée. Voir la documentation Plugiciel WildFly Maven pour plus d’informations.

Si vous utilisez Linux ou MacOS :

./mvnw clean wildfly:run

Windows :

mvnw.cmd clean wildfly:run

Pointez votre navigateur sur http://localhost:3000. Suivez le lien Log In (Connexion) pour vous connecter ou vous inscrire à votre locataire Auth0.

Une fois la connexion réussie, vous verrez l’image du profil de l’utilisateur et un menu déroulant à l’endroit où se trouvait le lien Log In (Connexion). Vous pouvez alors consulter la page de profil de l’utilisateur en cliquant sur le lien Profile (Profil). Vous pouvez vous déconnecter en cliquant sur le lien Logout (Déconnexion) dans le menu déroulant.