Shiro安全框架

一、什么是Shiro？

Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。

使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。

Apache Shiro 的首要目标是易于使用和理解。安全有时候是很复杂的，甚至是痛苦的，但它没有必要这样。框架应该尽可能掩盖复杂的地方，露出一个干净而直观的 API，来简化开发人员在使他们的应用程序安全上的努力。

以下是你可以用 Apache Shiro 所做的事情：

1）、验证用户来核实他们的身份（登录）

2）、对用户执行访问控制（权限），如：判断用户是否被分配了一个确定的安全角色，判断用户是否被允许做某事

3）、在任何环境下使用 Session API，即使没有 Web 或 EJB 容器。

4）、在身份验证，访问控制期间或在会话的生命周期，对事件作出反应。

5）、聚集一个或多个用户安全数据的数据源，并作为一个单一的复合用户“视图”。

6）、启用单点登录（SSO）功能。

7）、为没有关联到登录的用户启用"Remember Me"服务

二、与Spring Security的对比

Shiro：（轻量级）

Shiro较之 Spring Security，Shiro在保持强大功能的同时，还在简单性和灵活性方面拥有巨大优势。

1、易于理解的 Java Security API；

2、简单的身份认证（登录），支持多种数据源（LDAP，JDBC，Kerberos，ActiveDirectory 等）；

3、对角色的简单的签权（访问控制），支持细粒度的签权（方法级别）；

4、支持一级缓存，以提升应用程序的性能；

5、内置的基于 POJO 企业会话管理，适用于 Web 以及非 Web 的环境；

6、异构客户端会话访问；

7、非常简单的加密 API；

8、不跟任何的框架或者容器捆绑，可以独立运行；

Spring Security：（重量级）

除了不能脱离Spring，shiro的功能它都有。而且Spring Security对Oauth、OpenID也有支持,Shiro则需要自己手动实现。

Spring Security的权限细粒度更高。

三、Shiro的功能模块

Shiro可以非常容易的开发出足够好的应用，其不仅可以用在JavaSE环境，也可以用在JavaEE环境。Shiro可以帮助我们完成：认证、授权、加密、会话管理、与Web集成、缓存等。这不就是我们想要的嘛，而且Shiro的API也是非常简单；

其基本功能点如下图所示：

• Authentication：身份认证/登录，验证用户是不是拥有相应的身份。

• Authorization：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情。

• Session Management：会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通JavaSE环境的，也可以是如Web环境的。

• Cryptography：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储。

• Web Support：Shiro 的 web 支持的 API 能够轻松地帮助保护 Web 应用程序。

• Caching：缓存，比如用户登录后，其用户信息、拥有的角色/权限不必每次去查，这样可以提高效率。

• Concurrency：Apache Shiro 利用它的并发特性来支持多线程应用程序。

• Testing：测试支持的存在来帮助你编写单元测试和集成测试，并确保你的能够如预期的一样安全。

• "Run As"：一个允许用户假设为另一个用户身份（如果允许）的功能，有时候在管理脚本很有用。

四、Shiro的内部结构

Subject：主体，可以看到主体可以是任何可以与应用交互的“用户”；

SecurityManager：相当于SpringMVC中的DispatcherServlet或者Struts2中的FilterDispatcher；是Shiro的心脏；所有具体的交互都通过SecurityManager进行控制；它管理着所有Subject、且负责进行认证和授权、及会话、缓存的管理。

Authenticator：认证器，负责主体认证的，这是一个扩展点，如果用户觉得Shiro默认的不好，可以自定义实现；其需要认证策略（Authentication Strategy），即什么情况下算用户认证通过了；

Authrizer：授权器，或者访问控制器，用来决定主体是否有权限进行相应的操作；即控制着用户能访问应用中的哪些功能；

Realm：可以有1个或多个Realm，可以认为是安全实体数据源，即用于获取安全实体的；可以是JDBC实现，也可以是LDAP实现，或者内存实现等等；由用户提供；注意：Shiro不知道你的用户/权限存储在哪及以何种格式存储；所以我们一般在应用中都需要实现自己的Realm；

SessionManager：如果写过Servlet就应该知道Session的概念，Session呢需要有人去管理它的生命周期，这个组件就是SessionManager；而Shiro并不仅仅可以用在Web环境，也可以用在如普通的JavaSE环境、EJB等环境；所有呢，Shiro就抽象了一个自己的Session来管理主体与应用之间交互的数据；

SessionDAO：DAO大家都用过，数据访问对象，用于会话的CRUD，比如我们想把Session保存到数据库，那么可以实现自己的SessionDAO，通过如JDBC写到数据库；比如想把Session放到Memcached中，可以实现自己的

Memcached SessionDAO；另外SessionDAO中可以使用Cache进行缓存，以提高性能；

CacheManager：缓存控制器，来管理如用户、角色、权限等的缓存的；因为这些数据基本上很少去改变，放到缓存中后可以提高访问的性能

Cryptography：密码模块，Shiro提高了一些常见的加密组件用于如密码加密/解密的。

五、应用程序使用Shiro

 也就是说对于我们而言，最简单的一个Shiro应用：

1、应用代码通过Subject来进行认证和授权，而Subject又委托给SecurityManager；

2、我们需要给Shiro的SecurityManager注入Realm，从而让SecurityManager能得到合法的用户及其权限进行判断。

从以上也可以看出，Shiro不提供维护用户/权限，而是通过Realm让开发人员自己注入。

六、Shiro的入门

1、创建一个父工程下的maven子工程

使用IDEA创建一个空工程，File→new→project→empty project

点击next

 点击finish

 点击create

这样我们就创建了一个空的工程， 我们在这个空的工程中创建小的模块。

点击Modules→点击+号→点击new Module→点击maven

点击next

点击finish

点击ok

在setting中设置maven和本地仓库

2、引入依赖

<dependencies>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version>1.3.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.1.3</version>
        </dependency>
    </dependencies>

3、在resource目录下创建shiro的ini配置文件构造模拟数据

认证：身份认证/登录，验证用户是不是拥有相应的身份。基于shiro的认证，是通过subject的login方法完成用户认证工作的

[users]
#模拟从数据库查询的用户
#数据格式  用户名=密码
zhangsan=123456
lisi=654321

4、测试用户认证

创建ShiroTest01测试类

测试用户认证：

1、根据配置文件创建SecurityManagerFactory

2、通过工厂获取SecurityManager

3、将SecurityManager绑定到当前运行环境

4、从当前运行环境中构造subject

5、构造shiro登录的数据

6、主体登陆

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.util.Factory;
import org.junit.Test;

/**
 * @author zhouwenhao
 * @date 2021/11/30
 * @dec 描述
 */
public class ShiroTest01 {
    @Test
    public void testLogin() throws Exception{
        //1.通过shiro提供的对象IniSecurityManagerFactory加载ini配置文件创建SecurityManagerFactory
        Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-auth.ini");
        //2.获取securityManager
        SecurityManager securityManager = factory.getInstance();
        //3.将securityManager绑定到当前运行环境
        SecurityUtils.setSecurityManager(securityManager);
        //4.创建主体(此时的主体还为经过认证)
        Subject subject = SecurityUtils.getSubject();
        /**
         * 模拟登录，和传统等不同的是需要使用主体进行登录
         */
        //5.构造主体登录的凭证（即用户名/密码）
        //第一个参数：登录用户名，第二个参数：登录密码
        UsernamePasswordToken upToken = new UsernamePasswordToken("zhangsan","123456");
        //6.主体登录
        subject.login(upToken);
        //7.验证是否登录成功
        System.out.println("用户登录成功="+subject.isAuthenticated());
        //8.登录成功获取数据
        //getPrincipal 获取登录成功的安全数据
        System.out.println(subject.getPrincipal());
    }
}

 结果如下：

用户登录成功=true
zhangsan

如果密码为12345写错了，报错如下：

org.apache.shiro.authc.IncorrectCredentialsException: Submitted credentials for token 
[org.apache.shiro.authc.UsernamePasswordToken - zhangsan, rememberMe=false] did not match the expected credentials.

 

5、用户授权

授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情，常见的如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限

在resource目录下创建shiro-auth2.ini配置文件构造模拟数据

[users]
#模拟从数据库查询的用户
#数据格式  用户名=密码,角色1,角色2..
zhangsan=123456,role1,role2
lisi=654321,role2
[roles]
#模拟从数据库查询的角色和权限列表
#数据格式  角色名=权限1，权限2
role1=user:save,user:update
role2=user:update,user.delete
role3=user.find

zhangsan拥有角色1和角色2，即不仅可以新增和修改，还可以删除，lisi拥有角色2，只能修改和删除。

完成用户授权

创建测试类ShiroTest2

public class ShiroTest2 {
    private SecurityManager securityManager;
　　// 公共的内容以before的形式抽取出来
    @Before
    public void init() {
        //1.根据配置文件创建SecurityManagerFactory
        Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-auth2.ini");
        //2.通过工厂获取SecurityManager
        SecurityManager securityManager = factory.getInstance();
        //3.将SecurityManager绑定到当前运行环境
        SecurityUtils.setSecurityManager(securityManager);
    }

    @Test
    public void testLogin() {
        Subject subject = SecurityUtils.getSubject();
        String username = "zhangsan";
        String password = "123456";
        UsernamePasswordToken token = new UsernamePasswordToken(username,password);
        subject.login(token);

        //登录成功之后，完成授权
        //授权：检验当前登录用户是否具有操作权限，是否具有某个角色
        System.out.println(subject.hasRole("role1"));
        System.out.println(subject.isPermitted("user:save"));
    }
}

结果

true
true

七、自定义Realm

真是企业的应用，用户的数据和权限的信息是存放到数据库中的，我们要从数据库提取，而Realm是安全数据的来源。那如何定义Realm,以及如何在Realm中完成用户的认证和授权。

Realm域：Shiro从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；可以把Realm看成DataSource，即安全数据源

1、在resources目录下新建shiro-auth3.ini配置文件

[main]
#声明realm
permReam=com.zwh.shiro.PermissionRealm
#注册realm到securityManager中
securityManager.realms=$permReam

2、自定义PermissionRealm类

在src/main/java目录下创建com.zwh.shiro包，在包下自定义PermissionRealm类

自定义realm对象，继承AuthorizingRealm，重写方法：

• doGetAuthorizationInfo：授权，获取到用户的授权数据（用户的权限数据）

• doGetAuthenticationInfo：认证，根据用户名密码登录，将用户数据保存（安全数据）

public class PermissionRealm extends AuthorizingRealm {

    /**
     * 自定义realm名称，当Realm很多时，在shiro中的认证处理是根据名称来做的。在这里setName后，就可以通过getName获取到名称
     */
    public void setName(String name) { 
        super.setName("permissionRealm");  // 名称与类名相同
    }

    //授权:授权的主要目的就是根据认证数据(如用户名)获取到用户的权限信息

    /**
     * principalCollection：包含了所有已认证的安全数据
     * AuthorizationInfoInfo：授权数据
     */
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("执行授权方法");
        //1.获取安全数据  username，用户id
        String username = (String)principalCollection.getPrimaryPrincipal();
        //2.根据id或者名称查询用户
        //3.查询用户的角色和权限信息，这里我们造数据模拟从数据库查询角色和操作权限信息
        List<String> perms = new ArrayList<>();
        perms.add("user:save");
        perms.add("user:update");
        List<String> roles = new ArrayList<>();
        roles.add("role1");
        roles.add("role2");
        //4.构造返回，SimpleAuthorizationInfo为AuthorizationInfo接口的实现类
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        //设置权限集合
        info.addStringPermissions(perms);
        //设置角色集合
        info.addRoles(roles); // 这样就拥有了role1,role2角色和save,update权限
        return info;
    }

    //认证：认证的主要目的，比较用户名和密码是否与数据库中的一致
    //比较成功的话，将安全数据存入到shiro进行保管
    //参数：authenticationToken登录构造的usernamepasswordtoken
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        System.out.println("执行认证方法");
        //1.构造uptoken
        UsernamePasswordToken upToken = (UsernamePasswordToken) authenticationToken; // 强转成UsernamePasswordToken
        //2.获取输入的用户名密码
        String username = upToken.getUsername();
        String password = new String(upToken.getPassword()); // 因为密码是数组的形式
        //3.根据用户名查询数据库，正式系统查询
        //4.比较密码和数据库中的密码是否一致（密码可能需要加密）
        if("123456".equals(password)) { // 由于没有数据库，我们比较一下密码就来模拟查数据库
            //5.如果成功，向shiro存入安全数据
            //1.安全数据，2.密码。3。当前realm域名称,SimpleAuthenticationInfo是AuthenticationInfo接口的实现类
            SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(username,password,getName()); 
            return info;
        }else{
            //6.失败，抛出异常或返回null
            throw new RuntimeException("用户名或密码错误");
        }
    }
}

3、创建测试类进行测试

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.util.Factory;
import org.junit.Before;
import org.junit.Test;

public class ShiroTest3 {
    private SecurityManager securityManager;

    @Before
    public void init() {
        //1.根据配置文件创建SecurityManagerFactory
        Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-auth3.ini");
        //2.通过工厂获取SecurityManager
        SecurityManager securityManager = factory.getInstance();
        //3.将SecurityManager绑定到当前运行环境
        SecurityUtils.setSecurityManager(securityManager);
    }

    @Test
    public void testLogin() {
        Subject subject = SecurityUtils.getSubject();
        String username = "zhangsan";
        String password = "123456";
        UsernamePasswordToken token = new UsernamePasswordToken(username,password);

        // 执行login方法-->会自动找realm域中的认证方法
        subject.login(token);

        //授权：-->自动根据realm域中的授权方法去匹配
        System.out.println(subject.hasRole("role1"));
        System.out.println(subject.isPermitted("user:save"));

    }
}

结果如下:

执行认证方法
执行授权方法
true
执行授权方法
true

最终项目的目录结构为：

八、认证与授权的执行流程分析

1、认证流程

1）、首先调用Subject.login(token)进行登录，其会自动委托给Security Manager，调用之前必须通过SecurityUtils. setSecurityManager()设置；

2）、SecurityManager负责真正的身份验证逻辑；它会委托给Authenticator进行身份验证；

3）、Authenticator才是真正的身份验证者，Shiro API中核心的身份认证入口点，此处可以自定义插入自己的实现

4）、Authenticator可能会委托给相应的AuthenticationStrategy进行多Realm身份验证，默认ModularRealmAuthenticator会调用AuthenticationStrategy进行多Realm身份验证；

5）、Authenticator会把相应的token传入Realm，从Realm获取身份验证信息，如果没有返回/抛出异常表示身份验证失败了。此处可以配置多个Realm，将按照相应的顺序及策略进行访问。

要追踪认证的整个流程，我们可以debug启动

点击单步进入，F7

 通过securityManager调用login方法来执行，按F7进入securityManager的login方法

 按F7进入，authenticator为认证器，

  按F7进入，

   按F7进入，shiro获取所有的Realms,size为1，表示只有一个Realm，而且是我们自定义的Realm.

按F7进入，执行我们自定义PermissionRealm的认证方法

按F7进入，

按F7进入，这样就进入到了我们自定义的认证方法

2、授权流程

1. 首先调用Subject.isPermitted/hasRole接口，其会委托给SecurityManager，而SecurityManager接着会委托给Authorizer；

2. Authorizer是真正的授权者，如果我们调用如isPermitted(“user:view”)，其首先会通过PermissionResolver把字符串转换成相应的Permission实例；

3. 在进行授权之前，其会调用相应的Realm获取Subject相应的角色/权限用于匹配传入的角色/权限；

4. Authorizer会判断Realm的角色/权限是否和传入的匹配，如果有多个Realm，会委托给ModularRealmAuthorizer进行循环判断，如果匹配如isPermitted/hasRole会返回true，否则返回false表示授权失败。