Java 安全框架Apache Shiro和Spring Security比较

￡神魔★判官ぃ 2023-09-27 11:13 8阅读 0赞

### **1. 概述** ###

安全性是应用程序开发领域的主要关注点，尤其是在企业 Web 和移动应用程序领域。

在这个快速教程中，**我们将比较两个流行的 Java 安全框架[——Apache Shiro][Apache Shiro]和[Spring Security][]**。

### **2. 一点背景** ###

Apache Shiro 诞生于 2004 年，当时名为 JSecurity，并于 2008 年被 Apache 基金会接受。迄今为止，它已经发布了许多版本，截至撰写本文时最新的是 1.5.3。

Spring Security 于 2003 年作为 Acegi 开始，并在 2008 年首次公开发布时并入 Spring Framework。自成立以来，它已经经历了多次迭代，截至撰写本文时，当前的 GA 版本是 5.3.2。

两种技术都提供**身份验证和授权支持以及加密和会话管理解决方案**。此外，Spring Security 提供一流的保护，以抵御 CSRF 和会话固定等攻击。

在接下来的几节中，我们将看到这两种技术如何处理身份验证和授权的示例。为简单起见，我们将使用基于 Spring Boot 的基本 MVC 应用程序和[FreeMarker 模板][FreeMarker]。

### **3. 配置 Apache Shiro** ###

首先，让我们看看这两个框架之间的配置有何不同。

#### **3.1。Maven 依赖项** ####

由于我们将在 Spring Boot 应用程序中使用 Shiro，因此我们需要它的启动器和*shiro-core*模块：

<dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-spring-boot-web-starter</artifactId>
        <version>1.5.3</version>
    </dependency>
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-core</artifactId>
        <version>1.5.3</version>
    </dependency>

最新版本可以在[Maven Central][]上找到。

#### **3.2. 创建领域** ####

为了在内存中声明用户的角色和权限，我们需要创建一个扩展 Shiro 的*JdbcRealm*的领域。我们将定义两个用户——Tom 和 Jerry，分别具有 USER 和 ADMIN 角色：

public class CustomRealm extends JdbcRealm {
    
        private Map<String, String> credentials = new HashMap<>();
        private Map<String, Set> roles = new HashMap<>();
        private Map<String, Set> permissions = new HashMap<>();
    
        {
            credentials.put("Tom", "password");
            credentials.put("Jerry", "password");
    
            roles.put("Jerry", new HashSet<>(Arrays.asList("ADMIN")));
            roles.put("Tom", new HashSet<>(Arrays.asList("USER")));
    
            permissions.put("ADMIN", new HashSet<>(Arrays.asList("READ", "WRITE")));
            permissions.put("USER", new HashSet<>(Arrays.asList("READ")));
        }
    }

接下来，要启用此身份验证和授权的检索，我们需要重写一些方法：

@Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) 
      throws AuthenticationException {
        UsernamePasswordToken userToken = (UsernamePasswordToken) token;
    
        if (userToken.getUsername() == null || userToken.getUsername().isEmpty() ||
          !credentials.containsKey(userToken.getUsername())) {
            throw new UnknownAccountException("User doesn't exist");
        }
        return new SimpleAuthenticationInfo(userToken.getUsername(), 
          credentials.get(userToken.getUsername()), getName());
    }
    
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        Set roles = new HashSet<>();
        Set permissions = new HashSet<>();
    
        for (Object user : principals) {
            try {
                roles.addAll(getRoleNamesForUser(null, (String) user));
                permissions.addAll(getPermissions(null, null, roles));
            } catch (SQLException e) {
                logger.error(e.getMessage());
            }
        }
        SimpleAuthorizationInfo authInfo = new SimpleAuthorizationInfo(roles);
        authInfo.setStringPermissions(permissions);
        return authInfo;
    }

*doGetAuthorizationInfo*方法使用几个辅助方法来获取用户的角色和权限：

@Override
    protected Set getRoleNamesForUser(Connection conn, String username) 
      throws SQLException {
        if (!roles.containsKey(username)) {
            throw new SQLException("User doesn't exist");
        }
        return roles.get(username);
    }
    
    @Override
    protected Set getPermissions(Connection conn, String username, Collection roles) 
      throws SQLException {
        Set userPermissions = new HashSet<>();
        for (String role : roles) {
            if (!permissions.containsKey(role)) {
                throw new SQLException("Role doesn't exist");
            }
            userPermissions.addAll(permissions.get(role));
        }
        return userPermissions;
    }

接下来，我们需要将此*CustomRealm*作为 bean 包含在我们的引导应用程序中：

@Bean
    public Realm customRealm() {
        return new CustomRealm();
    }

此外，要为我们的端点配置身份验证，我们需要另一个 bean：

@Bean
    public ShiroFilterChainDefinition shiroFilterChainDefinition() {
        DefaultShiroFilterChainDefinition filter = new DefaultShiroFilterChainDefinition();
    
        filter.addPathDefinition("/home", "authc");
        filter.addPathDefinition("/**", "anon");
        return filter;
    }

在这里，使用*DefaultShiroFilterChainDefinition*实例，我们指定我们的*/home*端点只能由经过身份验证的用户访问。

这就是我们所需要的配置，Shiro 为我们完成其余的工作。

### **4.配置Spring Security** ###

现在让我们看看如何在 Spring 中实现同样的效果。

#### **4.1。Maven 依赖项** ####

首先，依赖关系：

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>

最新版本可以在[Maven Central][Maven Central 1]上找到。

#### **4.2. 配置类** ####

接下来，我们将在类*SecurityConfig*中定义我们的 Spring Security 配置，扩展*WebSecurityConfigurerAdapter*：

@EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
            http
              .authorizeRequests(authorize -> authorize
                .antMatchers("/index", "/login").permitAll()
                .antMatchers("/home", "/logout").authenticated()
                .antMatchers("/admin/**").hasRole("ADMIN"))
              .formLogin(formLogin -> formLogin
                .loginPage("/login")
                .failureUrl("/login-error"));
        }
    
        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception {
            auth.inMemoryAuthentication()
              .withUser("Jerry")
                .password(passwordEncoder().encode("password"))
                .authorities("READ", "WRITE")
                .roles("ADMIN")
                .and()
              .withUser("Tom")
                .password(passwordEncoder().encode("password"))
                .authorities("READ")
                .roles("USER");
        }
    
        @Bean
        public PasswordEncoder passwordEncoder() {
            return new BCryptPasswordEncoder();
        }
    }

如我们所见，我们构建了一个*AuthenticationManagerBuilder*对象来声明我们的用户及其角色和权限。*此外，我们使用BCryptPasswordEncoder*对密码进行了编码。

Spring Security 还为我们提供了它的*HttpSecurity*对象以进行进一步的配置。对于我们的示例，我们允许：

*  每个人都可以访问我们的*索引*和*登录*页面
 *  只有经过身份验证的用户才能进入*主页*并*注销*
 *  只有具有 ADMIN 角色的用户才能访问*管理*页面

我们还定义了对基于表单的身份验证的支持，以将用户发送到*登录*端点。如果登录失败，我们的用户将被重定向到*/login-error*。

### **5. 控制器和端点** ###

现在让我们看看这两个应用程序的 Web 控制器映射。虽然它们将使用相同的端点，但某些实现会有所不同。

#### **5.1。视图渲染端点** ####

对于渲染视图的端点，实现是相同的：

@GetMapping("/")
    public String index() {
        return "index";
    }
    
    @GetMapping("/login")
    public String showLoginPage() {
        return "login";
    }
    
    @GetMapping("/home")
    public String getMeHome(Model model) {
        addUserAttributes(model);
        return "home";
    }

我们的控制器实现，Shiro 和 Spring Security，在根端点上返回*index.ftl*，在登录端点上返回*login.ftl ，在主端点上返回**home.ftl*。

但是，*/home端点上方法**addUserAttributes*的定义在两个控制器之间会有所不同。此方法内省当前登录用户的属性。

Shiro 提供了一个*SecurityUtils\#getSubject*来检索当前的*Subject*及其角色和权限：

private void addUserAttributes(Model model) {
        Subject currentUser = SecurityUtils.getSubject();
        String permission = "";
    
        if (currentUser.hasRole("ADMIN")) {
            model.addAttribute("role", "ADMIN");
        } else if (currentUser.hasRole("USER")) {
            model.addAttribute("role", "USER");
        }
        if (currentUser.isPermitted("READ")) {
            permission = permission + " READ";
        }
        if (currentUser.isPermitted("WRITE")) {
            permission = permission + " WRITE";
        }
        model.addAttribute("username", currentUser.getPrincipal());
        model.addAttribute("permission", permission);
    }

另一方面，Spring Security为此目的从其*SecurityContextHolder的上下文中提供了一个**Authentication对象：*

private void addUserAttributes(Model model) {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        if (auth != null && !auth.getClass().equals(AnonymousAuthenticationToken.class)) {
            User user = (User) auth.getPrincipal();
            model.addAttribute("username", user.getUsername());
            Collection<GrantedAuthority> authorities = user.getAuthorities();
    
            for (GrantedAuthority authority : authorities) {
                if (authority.getAuthority().contains("USER")) {
                    model.addAttribute("role", "USER");
                    model.addAttribute("permissions", "READ");
                } else if (authority.getAuthority().contains("ADMIN")) {
                    model.addAttribute("role", "ADMIN");
                    model.addAttribute("permissions", "READ WRITE");
                }
            }
        }
    }

#### **5.2. POST 登录端点** ####

在 Shiro 中，我们将用户输入的凭据映射到 POJO：

public class UserCredentials {
    
        private String username;
        private String password;
    
        // getters and setters
    }

然后我们将创建一个*UsernamePasswordToken*来记录用户或*Subject*，在：

@PostMapping("/login")
    public String doLogin(HttpServletRequest req, UserCredentials credentials, RedirectAttributes attr) {
    
        Subject subject = SecurityUtils.getSubject();
        if (!subject.isAuthenticated()) {
            UsernamePasswordToken token = new UsernamePasswordToken(credentials.getUsername(),
              credentials.getPassword());
            try {
                subject.login(token);
            } catch (AuthenticationException ae) {
                logger.error(ae.getMessage());
                attr.addFlashAttribute("error", "Invalid Credentials");
                return "redirect:/login";
            }
        }
        return "redirect:/home";
    }

在 Spring Security 方面，这只是重定向到主页的问题。**Spring 的登录过程，由它的*UsernamePasswordAuthenticationFilter*处理，对我们来说是透明的**：

@PostMapping("/login")
    public String doLogin(HttpServletRequest req) {
        return "redirect:/home";
    }

#### **5.3. 仅限管理员的端点** ####

现在让我们看一下我们必须执行基于角色的访问的场景。假设我们有一个*/admin*端点，只应允许 ADMIN 角色访问该端点。

让我们看看如何在 Shiro 中做到这一点：

@GetMapping("/admin")
    public String adminOnly(ModelMap modelMap) {
        addUserAttributes(modelMap);
        Subject currentUser = SecurityUtils.getSubject();
        if (currentUser.hasRole("ADMIN")) {
            modelMap.addAttribute("adminContent", "only admin can view this");
        }
        return "home";
    }

在这里，我们提取了当前登录的用户，检查他们是否具有 ADMIN 角色，并相应地添加了内容。

在 Spring Security 中，不需要以编程方式检查角色，我们已经在*SecurityConfig*中定义了谁可以到达这个端点。所以现在，只需添加业务逻辑：

@GetMapping("/admin")
    public String adminOnly(HttpServletRequest req, Model model) {
        addUserAttributes(model);
        model.addAttribute("adminContent", "only admin can view this");
        return "home";
    }

#### **5.4. 注销端点** ####

最后，让我们实现注销端点。

在 Shiro 中，我们将简单地调用*Subject\#logout*：

@PostMapping("/logout")
    public String logout() {
        Subject subject = SecurityUtils.getSubject();
        subject.logout();
        return "redirect:/";
    }

对于 Spring，我们没有为注销定义任何映射。在这种情况下，它的默认注销机制启动，这是自动应用的，因为我们在配置中扩展了*WebSecurityConfigurerAdapter*。

### **6. Apache Shiro 与 Spring Security** ###

现在我们已经了解了实现差异，让我们看看其他一些方面。

在社区支持方面，**Spring Framework 总体上拥有庞大的开发者社区**，积极参与其开发和使用。由于 Spring Security 是保护伞的一部分，它必须享有同样的优势。Shiro虽然很受欢迎，但没有如此巨大的支持。

关于文档，Spring 再次成为赢家。

但是，有一点与 Spring Security 相关的学习曲线。**另一方面，Shiro 很容易理解**。对于桌面应用程序，通过*[shiro.ini][]*进行配置更加容易。

但是，正如我们在示例代码片段中看到的那样， Spring Security 在保持业务逻辑和安全性**分离****方面做得很好，** 并且真正将安全性作为横切关注点提供。

### **7. 结论** ###

在本教程中，**我们将 Apache Shiro 与 Spring Security 进行了比较**。

我们刚刚了解了这些框架所提供的功能，还有很多需要进一步探索。有很多替代品，例如[JAAS][]和[OACC][]。尽管如此，凭借其优势，[Spring Security][Spring Security 1]似乎在这一点上取得了胜利。

与往常一样，源代码可[在 GitHub 上][GitHub]获得。

[Apache Shiro]: https://shiro.apache.org/
[Spring Security]: https://spring.io/projects/spring-security
[FreeMarker]: https://www.baeldung.com/spring-template-engines#4-freemarker-in-spring-boot
[Maven Central]: https://search.maven.org/classic/#search%7Cga%7C1%7Cg%3A%22org.apache.shiro%22
[Maven Central 1]: https://search.maven.org/classic/#search%7Cga%7C1%7Cg%3A%22org.springframework.boot%22%20AND%20a%3A%22spring-boot-starter%22
[shiro.ini]: https://shiro.apache.org/configuration.html#Configuration-CreatingaSecurityManagerfromINI
[JAAS]: https://docs.oracle.com/en/java/javase/11/security/java-authentication-and-authorization-service-jaas-reference-guide.html
[OACC]: http://oaccframework.org/
[Spring Security 1]: https://www.baeldung.com/security-spring
[GitHub]: https://github.com/eugenp/tutorials/tree/master/security-modules/apache-shiro