shiro-安全框架

码农终将翻身

已于 2022-10-29 14:18:06 修改

阅读量704

点赞数 1

分类专栏： Java 文章标签：安全 shiro

于 2022-08-04 01:45:18 首次发布

本文链接：https://blog.csdn.net/weixin_68509156/article/details/126151647

版权

Java 专栏收录该内容

39 篇文章 7 订阅

订阅专栏

1. 了解shiro安全框架

1.1. 什么是权限管理

基本上涉及到用户参与的系统都要进行权限管理，权限管理属于系统安全的范畴，权限管理实现对用户访问系统的控制，按照安全规则或者安全策略控制用户可以访问而且只能访问自己被授权的资源。

权限管理包括用户身份认证和授权两部分，简称认证授权。对于需要访问控制的资源用户首先经过身份认证，认证通过后用户具有该资源的访问权限方可访问。

1.2. 什么是身份认证

身份认证，就是判断一个用户是否为合法用户的处理过程。最常用的简单身份认证方式是系统通过核对用户输入的用户名和口令，看其是否与系统中存储的该用户的用户名和口令一致，来判断用户身份是否正确。对于采用指纹等系统，则出示指纹；对于硬件Key等刷卡系统，则需要刷卡。

1.3. 什么是授权

授权，即访问控制，控制谁能访问哪些资源。主体进行身份认证后需要分配权限方可访问系统的资源，对于某些资源没有权限是无法访问的

1.4. 认证授权框架有哪些

shiro 简单好学

spring security 它可以无缝整合spring框架

1.5. 什么shiro框架

Apache Shiro 是一个强大易用的 Java 安全框架，提供了认证、授权、加密和session会话管理等功能，对于任何一个应用程序，Shiro 都可以提供全面的安全管理服务。并且相对于其他安全框架spring security，Shiro 要简单的多.

Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。

1.6. 为什么学shiro

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

1.7. shiro中的概念

Subject

Subject主体，外部应用与subject进行交互，subject将用户作为当前操作的主体，这个主体：可以是一个通过浏览器请求的用户，也可能是一个运行的程序。Subject在shiro中是一个接口，接口中定义了很多认证授相关的方法，外部程序通过subject进行认证授，而subject是通过SecurityManager安全管理器进行认证授权

SecurityManager

SecurityManager权限管理器，它是shiro的核心，负责对所有的subject进行安全管理。通过SecurityManager可以完成subject的认证、授权等，SecurityManager是通过Authenticator进行认证，通过Authorizer进行授权，通过SessionManager进行会话管理等。SecurityManager是一个接口，继承了Authenticator, Authorizer, SessionManager这三个接口

Authenticator

Authenticator即认证器，对用户登录时进行身份认证

Authorizer

Authorizer授权器，用户通过认证器认证通过，在访问功能时需要通过授权器判断用户是否有此功能的操作权限。

Realm（数据库读取+认证功能+授权功能实现）

Realm领域，相当于datasource数据源，securityManager进行安全认证需要通过Realm获取用户权限数据
比如：
如果用户身份数据在数据库那么realm就需要从数据库获取用户身份信息。
注意：
不要把realm理解成只是从数据源取数据，在realm中还有认证授权校验的相关的代码。

SessionManager

SessionManager会话管理，shiro框架定义了一套会话管理，它不依赖web容器的session，所以shiro可以使用在非web应用上，也可以将分布式应用的会话集中在一点管理，此特性可使它实现单点登录。

SessionDAO

SessionDAO即会话dao，是对session会话操作的一套接口
比如:
可以通过jdbc将会话存储到数据库
也可以把session存储到缓存服务器

CacheManager

CacheManager缓存管理，将用户权限数据存储在缓存，这样可以提高性能。

Cryptography

Cryptography密码管理，shiro提供了一套加密/解密的组件，方便开发。比如提供常用的散列、加/解密等功能

2. 使用shiro完成认证工作

2.1. shiro中认证的关键对象

Subject：主体访问系统的用户，主体可以是用户、程序等，进行认证的都称为主体；

Principal：身份信息----账号是主体（subject）进行身份认证的标识，标识必须具有唯一性，如用户名、手机号、邮箱地址等，一个主体可以有多个身份，但是必须有一个主身份（Primary Principal）。

credential：凭证信息---密码是只有主体自己知道的安全信息，如密码、证书等。

2.2. 认证流程

2.3. 使用shiro完成身份认证

先不用数据库来进行身份认证，--我们ini文件，window系统文件，该文件中可以存放账号和密码。

(1) 创建一个maven java工程

        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version>1.9.0</version>
        </dependency>

(2) 创建ini文件模拟数据

[users]-----表示表名
# 账号=密码
admin=123456
ldh=123456

(3) 测试代码

package com.wzh.shiro01;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.realm.text.IniRealm;
import org.apache.shiro.subject.Subject;

/**
 * @ProjectName: shiro
 * @Package: com.wzh.shiro01
 * @ClassName: TestShiro01
 * @Author: 王振华
 * @Description:
 * @Date: 2022/8/3 16:35
 * @Version: 1.0
 */
public class TestShiro01 {
    public static void main(String[] args) {
        //1.获取SecutiryManager对象
        DefaultSecurityManager securityManager = new DefaultSecurityManager();
        //2.读取ini文件
        IniRealm iniRealm = new IniRealm("classpath:shiro.ini");
        //3.设置securityManager的realm
        securityManager.setRealm(iniRealm);
        //4.设置securityManager上下文生效
        SecurityUtils.setSecurityManager(securityManager);

        //5.获取subject主题对象
        Subject subject = SecurityUtils.getSubject();
        try{
            //完成认证功能AuthenticationToken:该类把账号和密码封装到该类中。
            //UsernamePasswordToken作用就是封装你输入的账号和密码  是客户输入的账号和密码
            UsernamePasswordToken token = new UsernamePasswordToken("admin1", "123456");
            //抛出异常  比对shiro中realm自带对比
            subject.login(token);
            System.out.println("登录成功");
        }catch (Exception e){
            e.printStackTrace();
            System.out.println("账号或密码错误");
        }
    }
}

常见的异常类型

DisabledAccountException（帐号被禁用）

LockedAccountException（帐号被锁定）

ExcessiveAttemptsException（登录失败次数过多）

ExpiredCredentialsException（凭证过期）等

2.4. 认证的原理

流程如下：

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

SecurityManager 负责真正的身份验证逻辑；它会委托给 Authenticator 进行身份验证；Authenticator 才是真正的身份验证者，Shiro API 中核心的身份认证入口点，此处可以自定义插入自己的实现；

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

Subject主体: 登录信息提交给SecurityManager, --->认证器Authenticator---->根据你的realm提供的数据进行相关的认证。 realm---与数据源交互的类。

3.Shiro.ini文件 (了解)

3.1 什么是ini文件

ini (InitializationFile) 初始文件.Window系统文件扩展名.

3.2 为什么使用ini文件

1.Shiro 使用时可以连接数据库,也可以不连接数据库.
如果不连接数据库,可以在shiro.ini中配置静态数据

3.3 Shiro.ini文件的组成部分

[users] :定义用户名和密码
[users] ---->表示user表
# 定义用户名为zhangsan 密码为zs
zhangsan=zs //账号=密码
# 定义用户名lisi密码为lisi同时具有role1和role2两个角色
lisi=lisi,role1,role2

---------------------------------------------------------------
[roles]: 定义角色
[roles]
role1=权限名1,权限名2
role2=权限3,权限4
如
[roles]
role1=user:query,user:add,user:update,user:delete,user:export

role2=user:query,user:add

--------------------------------------------------------------
[urls] : 定义哪些内置urls生效.在web应用时使用.
[urls]
#url地址=内置filter或自定义filter
# 访问时出现/login的url必须去认证.支持authc对应的Filter
/login=authc
# 任意的url都不需要进行认证等功能.
/** = anon
# 所有的内容都必须保证用户已经登录.
/**=user
# url abc 访问时必须保证用户具有role1和role2角色.
/abc=roles[“role1,role2”]

authc 代表必须认证之后才能访问的路径
anon 任意的url都不需要进行认证等功能
user 所有的内容都必须保证用户已经登录.
logout 注销

4. 授权

一定是在认证成功后才会执行的代码。

修改ini文件

[users]
; 账号=密码,具有的角色
admin=123456,role1,role2
ldh=123456,role1

;定义角色

[roles]
; 角色名=具有的权限
role1=user:query,user:export
role=user:query,user:delete,user:save,user:update

修改代码

package com.wzh.shiro01;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.realm.text.IniRealm;
import org.apache.shiro.subject.Subject;

import java.util.Arrays;

/**
 * @ProjectName: shiro
 * @Package: com.wzh.shiro01
 * @ClassName: TestShiro01
 * @Author: 王振华
 * @Description:
 * @Date: 2022/8/3 16:35
 * @Version: 1.0
 */
public class TestShiro01 {
    public static void main(String[] args) {
        //1.获取SecutiryManager对象
        DefaultSecurityManager securityManager = new DefaultSecurityManager();
        //2.读取ini文件
        IniRealm iniRealm = new IniRealm("classpath:shiro.ini");
        //3.设置securityManager的realm
        securityManager.setRealm(iniRealm);
        //4.设置securityManager上下文生效
        SecurityUtils.setSecurityManager(securityManager);

        //5.获取subject主题对象
        Subject subject = SecurityUtils.getSubject();
        try{
            //UsernamePasswordToken作用就是封装你输入的账号和密码  是客户输入的账号和密码
            UsernamePasswordToken token = new UsernamePasswordToken("admin1", "123456");
            //抛出异常  比对shiro中realm自带对比
            subject.login(token);
            System.out.println("登录成功");
        }catch (Exception e){
            e.printStackTrace();
            System.out.println("账号或密码错误");
        }
        // subject.logout();
        System.out.println("====================================================登录后=====================================");
        //判断是否身份认证 
        boolean authenticated = subject.isAuthenticated();
        if(authenticated){
            //判断当前登录者是否具有user:query权限
            boolean permitted = subject.isPermitted("user:update");
            System.out.println(permitted);

            boolean permittedAll = subject.isPermittedAll("user:query", "user:save");
            System.out.println("判断当前用户是否同时具有user:query和user:save权限:"+permittedAll);

            boolean[] permitted1 = subject.isPermitted("user:query", "user:export");
            System.out.println(Arrays.toString(permitted1));

            //从角色角度
            boolean b = subject.hasRole("role1");
            System.out.println(b);
        }else{
            System.out.println("请先认证");
        }
    }
}

上面的代码，所有的数据都是基于ini文件，而实际开发数据应该从数据库。这时我们可以自定义realm

5.认证的底层源码

我们分析源码我们的最终认证交于realm完成认证功能，返回一个info, 如果info不为null,则进行密码比对。如果我们希望用数据库中的账号和密码完成认证功能，则只需要我们自定义一个类并继承AuthenticatingRealm。

6.自定义Realm实现认证

Shiro默认使用自带的IniRealm，IniRealm从ini配置文件中读取用户的信息，大部分情况下需要从系统的数据库中读取用户信息，所以需要自定义realm。

最基础的是Realm接口，CachingRealm负责缓存处理，AuthenticationRealm负责认证，AuthorizingRealm负责授权，通常自定义的realm继承AuthorizingRealm

（1）创建自定义realm类

package com.wzh.demo02;



import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.realm.AuthenticatingRealm;

/**
 * @ProjectName: shiro
 * @Package: com.wzh.demo02
 * @ClassName: MyRealm
 * @Author: 王振华
 * @Description:
 * @Date: 2022/8/4 19:44
 * @Version: 1.0
 */
public class MyRealm extends AuthenticatingRealm {
    UserService userService = new UserService();
    @Override
    //该方法用于完成认证的功能
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //1.根据token获取账号
        String username = (String) authenticationToken.getPrincipal();
        /**
         * 以前登陆的逻辑是  把用户和密码全部发到数据库  去匹配
         * 在shrio里面是先根据用户名把用户对象查询出来，再来做密码匹配
         */

        //2.根据账号查询用户信息
        User user = userService.findByUsername(username);
        //表示该用户名在数据库中存在
        if(user!=null){
            /**
             * 参数说明
             * 参数1:可以传到任意对象
             * 参数2:从数据库里面查询出来的密码
             * 参数3:当前类名
             */
            //Object principal,账号数据库中
            // Object credentials,密码数据库中
            // String realmName realm的名称随便起
            //密码的比对交于SimpleAuthenticationInfo
            SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user, user.getPassword(), this.getName());
            return info;
        }
        //用户不存在  shiro会抛 UnknowAccountException
        return null;
    }
}

（2）修改SecurityManager的realm对象

（3）service代码

package com.wzh.service;

import com.wzh.entity.User;

/**
 * @ProjectName: maven-shiro1028
 * @Package: com.wzh.service
 * @ClassName: UserService
 * @Date: 2022/10/28 19:12
 * @Version: 1.0
 */
public class UserService {
    public User findByUsername(String username) {
        if("admin".equals(username)){
            return new User("admin","123456");
        }else if("wzh".equals(username)){
            return new User("wzh","1234567");

        }
        return null;
    }
}

（4）测试

package com.wzh.demo02;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.subject.Subject;

/**
 * @ProjectName: shiro
 * @Package: com.wzh.demo02
 * @ClassName: TestShiro
 * @Author: 王振华
 * @Description:
 * @Date: 2022/8/4 19:56
 * @Version: 1.0
 */
public class TestShiro {
    public static void main(String[] args) {
        //获取SecurityManager对象
        DefaultSecurityManager securityManager = new DefaultSecurityManager();
        //创建Realm对象
        MyRealm myRealm = new MyRealm();
        //设置securityManager的realm
        securityManager.setRealm(myRealm);
        //设置securityManager上下文生效
        SecurityUtils.setSecurityManager(securityManager);

        //获取subject主体对象
        Subject subject = SecurityUtils.getSubject();
        try{
            //UsernamePasswordToken作用就是封装你输入的账号和密码 是客户输入的账号和密码
            UsernamePasswordToken token = new UsernamePasswordToken("admin", "123456");
            //抛出异常  比对shiro中realm自带的
            subject.login(token);
            System.out.println("登录成功");

        }catch (Exception e){
            e.printStackTrace();
            System.out.println("账号或密码错误");
        }
    }
}

7.密码加密

shiro它提供了很多的加密器。其中使用最多就是HashedCredentialsMatcher。它的底层使用的还是Md5加密。了解一下MD5加密

package com.wzh.demo03;

import org.apache.shiro.crypto.hash.Md5Hash;

/**
 * @ProjectName: shiro
 * @Package: com.wzh.demo03
 * @ClassName: MD5Utils
 * @Author: 王振华
 * @Description:
 * @Date: 2022/8/4 20:07
 * @Version: 1.0
 */
public class MD5Utils {
    public static void main(String[] args) {
        //source:需要加密的明文

        //MD5非对称加密
        //默认md5加密是不可逆的。但是网上有一些破解软件，解密网站会把常用的加密的内容搜集起来--造成了数据不安全
        Md5Hash hash = new Md5Hash("123456");
        System.out.println("使用MD5加密后的结果:"+hash);

        //salt:加盐加密  这个盐不能给别人
        Md5Hash hash1 = new Md5Hash("123456", "abc?!");
        System.out.println("使用MD5加密并加盐后的结果:"+hash1);

        //加密加盐并设置1024次加密
        Md5Hash hash2 = new Md5Hash("123456", "cccc", 1024);
        System.out.println("使用MD5加密加盐并散列1024次后的结果:"+hash2);
    }
}

7.1 shiro使用密码加密器

（1）设置realm的加密器

（2）修改myRealm代码

shiro会帮我们进行密码的比对。以为你为realm指定了加密器---shiro在比对密码时，先对你的密码进行加密，加密后再和数据库中的密码比对

（3）修改数据库的密码

加密的原理就是客户输入的密码 + 盐(user表中有一列salt，随机生成的) 通过MD5算法计算出来的值跟数据库的密码对比是否一致。

8.自定义Realm实现授权

package com.wzh.demo04;


import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthenticatingRealm;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;

import java.util.List;

/**
 * @ProjectName: shiro
 * @Package: com.wzh.demo02
 * @ClassName: MyRealm
 * @Author: 王振华
 * @Description:
 * @Date: 2022/8/4 19:44
 * @Version: 1.0
 */
public class MyRealm extends AuthorizingRealm {
    UserService userService = new UserService();
    @Override
    //该方法用于完成认证的功能
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //1.根据token获取账号
        String username = (String) authenticationToken.getPrincipal();
        /**
         * 以前登陆的逻辑是  把用户和密码全部发到数据库  去匹配
         * 在shrio里面是先根据用户名把用户对象查询出来，再来做密码匹配
         */

        //2.根据账号查询用户信息
        User user = userService.findByUsername(username);
        //表示该用户名在数据库中存在
        if(user!=null){
            /**
             * 参数说明
             * 参数1:可以传到任意对象
             * 参数2:从数据库里面查询出来的密码
             * 参数3:盐
             * 参数4:当前类名
             */
            ByteSource credentialsSalt = ByteSource.Util.bytes(user.getSalt());
            SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user, user.getPassword(),credentialsSalt,this.getName());
            return info;
        }
        //用户不存在  shiro会抛 UnknowAccountException
        return null;
    }

    //授权时执行该方法
    //什么时候执行该方法: 当你进行权限校验时会执行该方法
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //获取当前登录者的信息  也就是认证方法info的第一个参数
        User user = (User) principalCollection.getPrimaryPrincipal();
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        //根据账号查找该用户具有哪些权限
        List<String> list = userService.findPermissionByUsername(user.getUsername());
        if(list!=null&&list.size()>0){
            info.addStringPermissions(list);
        }
        List<String> roles = userService.findRolesByUsername(user.getUsername());
        if(roles!=null&&roles.size()>0){
            info.addRoles(roles);
        }
        return info;
    }
}

测试:

package com.wzh.demo04;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.subject.Subject;

/**
 * @ProjectName: shiro
 * @Package: com.wzh.demo02
 * @ClassName: TestShiro
 * @Author: 王振华
 * @Description:
 * @Date: 2022/8/4 19:56
 * @Version: 1.0
 */
public class TestShiro {
    public static void main(String[] args) {
        //获取SecurityManager对象
        DefaultSecurityManager securityManager = new DefaultSecurityManager();
        //创建Realm对象
        MyRealm myRealm = new MyRealm();

        //为realm指定加密器
        HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
        //指定加密算法
        credentialsMatcher.setHashAlgorithmName("MD5");
        //指定加密次数
        credentialsMatcher.setHashIterations(1024);
        myRealm.setCredentialsMatcher(credentialsMatcher);


        //设置securityManager的realm
        securityManager.setRealm(myRealm);
        //设置securityManager上下文生效
        SecurityUtils.setSecurityManager(securityManager);

        //获取subject主体对象
        Subject subject = SecurityUtils.getSubject();
        try{
            //UsernamePasswordToken作用就是封装你输入的账号和密码 是客户输入的账号和密码
            UsernamePasswordToken token = new UsernamePasswordToken("admin", "123456");
            //抛出异常  比对shiro中realm自带的
            subject.login(token);
            System.out.println("登录成功");


        }catch (Exception e){
            e.printStackTrace();
            System.out.println("账号或密码错误");
        }

        System.out.println(subject.getPrincipal());//拿到登录者的身份 其实就是Realm中返回info的第一个参数值
        //判断是否用户是否有权限query
        System.out.println(subject.isPermitted("user:query"));
        System.out.println(subject.isPermitted("user:update"));
        //判断用户是否认证
        System.out.println(subject.isAuthenticated());
        //判断用户是否有角色
        System.out.println(subject.hasRole("role1"));
    }
}