Développement back-end Java : Utilisation du service d'authentification et d'autorisation Java pour la gestion des autorisations multirôles API

Avec le développement d'Internet, les scénarios d'application de diverses applications Web et API deviennent de plus en plus étendus, et la gestion des autorisations multi-rôles des API est devenue un sujet de plus en plus important. Dans le développement back-end Java, Java Authentication and Authorization Service (JAAS) est une solution fiable. Il fournit un mécanisme de contrôle des autorisations basé sur les rôles qui nous permet de gérer facilement les autorisations d'accès aux interfaces API.

Dans le développement Java, le framework JAAS est l'abréviation de Java Authentication and Authorization Service. Il s'agit de l'une des API standard Java SE et est principalement utilisé pour l'authentification et l'autorisation des applications. Les concepts de base du cadre JAAS sont les sources de configuration et de stratégie, qui sont utilisées pour identifier et gérer différents types d'utilisateurs et stratégies d'accès dans un programme.

Le framework JAAS fournit deux abstractions principales : Sujet et LoginModule. Le sujet représente un utilisateur ou un groupe d'utilisateurs dans le programme, et LoginModule est l'implémentation spécifique de l'authentification et de l'autorisation. Le framework JAAS implémente un mécanisme de contrôle des autorisations basé sur les rôles via ces deux abstractions.

Voyons comment utiliser le framework JAAS pour implémenter la gestion des autorisations de rôle API.

1. Configuration de JAAS

Tout d'abord, JAAS doit être configuré. Nous pouvons créer un fichier de configuration dans le projet, par exemple : jaas.conf Le contenu du fichier de configuration est le suivant :

Sample {
    com.example.security.SimpleLoginModule required;
};

Dans la configuration ci-dessus, Sample est un nom de programme et com.example.security.SimpleLoginModule est. le nom de classe qui implémente l'interface LoginModule.

2. Implémentez l'interface LoginModule

Ensuite, vous devez implémenter une classe qui implémente l'interface LoginModule pour authentifier et autoriser les utilisateurs. L'exemple de code est le suivant :

package com.example.security;

import java.util.Map;
import javax.security.auth.Subject;
import javax.security.auth.callback.Callback;
import javax.security.auth.callback.CallbackHandler;
import javax.security.auth.callback.NameCallback;
import javax.security.auth.callback.PasswordCallback;
import javax.security.auth.callback.UnsupportedCallbackException;
import javax.security.auth.login.LoginException;
import javax.security.auth.spi.LoginModule;

public class SimpleLoginModule implements LoginModule {

    private Subject subject;
    private CallbackHandler callbackHandler;
    private Map<String, ?> sharedState;
    private Map<String, ?> options;
    private String username;

    public void initialize(
        Subject subject,
        CallbackHandler callbackHandler,
        Map<String, ?> sharedState,
        Map<String, ?> options
    ) {
        this.subject = subject;
        this.callbackHandler = callbackHandler;
        this.sharedState = sharedState;
        this.options = options;
    }

    public boolean login() throws LoginException {
        Callback[] callbacks = new Callback[2];
        callbacks[0] = new NameCallback("username: ");
        callbacks[1] = new PasswordCallback("password: ", false);

        try {
            callbackHandler.handle(callbacks);

            String username = ((NameCallback) callbacks[0]).getName();
            String password = String.valueOf(((PasswordCallback) callbacks[1]).getPassword());

            // 验证用户名和密码，通过返回true
            if ("admin".equals(username) && "123456".equals(password)) {
                this.username = username;
                return true;
            } else {
                throw new LoginException("Invalid username or password");
            }
        } catch (UnsupportedCallbackException | IOException e) {
            e.printStackTrace();
            throw new LoginException(e.getMessage());
        }
    }

    public boolean commit() throws LoginException {
        subject.getPrincipals().add(new SimplePrincipal(username));
        return true;
    }

    public boolean abort() throws LoginException {
        return true;
    }

    public boolean logout() throws LoginException {
        subject.getPrincipals().removeIf(principal -> principal.getName().equals(username));
        return true;
    }

}

Parmi eux, nous implémentons l'authentification et l'autorisation des utilisateurs en implémentant les méthodes dans l'interface LoginModule. Dans la méthode de connexion, nous utilisons le CallbackHandler pour obtenir le nom d'utilisateur et le mot de passe saisis par l'utilisateur et les authentifier ; dans la méthode de validation, nous ajoutons les informations de l'utilisateur au sujet pour une autorisation de rôle ultérieure.

3. Mise en œuvre de l'autorisation de rôle

Ensuite, l'autorisation de rôle doit être effectuée pour des interfaces API spécifiques. Nous pouvons utiliser les annotations fournies par Java EE pour l'autorisation, telles que :

@RolesAllowed({"admin","user"})
@Path("/api/hello")
public class HelloResource {

    @GET
    public Response greet() {
        return Response.ok("Hello World!").build();
    }

}

Dans l'exemple ci-dessus, nous utilisons l'annotation @RolesAllowed pour spécifier le rôle d'accès de l'API. Seuls les utilisateurs dotés des rôles d'administrateur et d'utilisateur peuvent accéder à l'API. interface.

4. Configurer le serveur d'applications

Enfin, pour ajouter le support JAAS sur le serveur d'applications, nous pouvons ajouter la configuration suivante dans server.xml :

<server>
  ...
  <featureManager>
    ...
    <feature>appSecurity-2.0</feature>
  </featureManager>
  ...
</server>

Ajoutez le code suivant dans web.xml :

<login-config>
  <auth-method>FORM</auth-method>
  <realm-name>sampleRealm</realm-name>
  <form-login-config>
    <form-login-page>/login.html</form-login-page>
    <form-error-page>/error.html</form-error-page>
  </form-login-config>
</login-config>

<security-constraint>
  <web-resource-collection>
    <web-resource-name>helloResource</web-resource-name>
    <url-pattern>/api/hello</url-pattern>
  </web-resource-collection>
  <auth-constraint>
    <role-name>admin</role-name>
    <role-name>user</role-name>
</auth-constraint>

Dans ce qui précède configuration, nous avons spécifié l'utilisation de la méthode d'authentification FORM et fourni la page correspondante pour la page. Dans le même temps, vous devez également spécifier une contrainte de sécurité pour autoriser le rôle de l'API /hello.

À ce stade, nous avons terminé la configuration de la gestion des autorisations multi-rôles de l'API.

Résumé

Le framework JAAS est l'abréviation de Java Authentication and Authorization Service. Il s'agit de l'une des API standard Java SE et est principalement utilisée pour authentifier et autoriser les applications. Dans le développement back-end Java, l'utilisation du framework JAAS pour la gestion des autorisations multi-rôles API peut facilement implémenter l'autorisation de rôle. Nous avons implémenté un mécanisme de contrôle des autorisations basé sur les rôles via des sources de configuration et de stratégie, utilisé l'interface LoginModule pour l'authentification et l'autorisation d'identité, et utilisé des annotations pour l'autorisation des rôles API. En configurant le serveur d'applications, nous avons finalement réalisé une gestion des autorisations multi-rôles API.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!