1、认证

身份认证，就是判断一个用户是否为合法用户的处理过程。最常用的简单身份认证方式是系统通过核对用户输入的用户名和口令，看其是否与系统中存储的该用户的用户名和口令一致，来判断用户身份是否正确。

1.1、shiro中认证的关键对象

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

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

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

1.2、认证流程

image.png

1.3、代码示例

1.3.1、创建项目并引入依赖

  1. <!-- https://mvnrepository.com/artifact/org.apache.shiro/shiro-core -->
  2. <dependency>
  3.   <groupId>org.apache.shiro</groupId>
  4.   <artifactId>shiro-core</artifactId>
  5.   <version>1.8.0</version>
  6. </dependency>

1.3.2、IniReal

引入shiro配置文件
配置文件：名称随意，以 .ini 结尾，放在 resources 目录下
注意：在实际的项目开发中并不会使用这种方式，这种方法可以用来初学时练手
shiro.ini

  1. [users]
  2. zhangsan=123
  3. lisi=123456
  1. package com.lms.shiro;
  3. import org.apache.shiro.SecurityUtils;
  4. import org.apache.shiro.authc.IncorrectCredentialsException;
  5. import org.apache.shiro.authc.UnknownAccountException;
  6. import org.apache.shiro.authc.UsernamePasswordToken;
  7. import org.apache.shiro.mgt.DefaultSecurityManager;
  8. import org.apache.shiro.realm.text.IniRealm;
  9. import org.apache.shiro.subject.Subject;
  11. /**
  12.  * @Author: 李孟帅
  13.  * @Date: 2021-12-06 17:13
  14.  * @Description:
  15.  */
  16. public class TestIniRealm {
  18.     public static void main(String[] args) {
  19.         //1.创建安全管理器对象
  20.         DefaultSecurityManager securityManager = new DefaultSecurityManager();
  21.         //2.给安全管理器设置realm
  22.         securityManager.setRealm(new IniRealm("classpath:shiro.ini"));
  23.         SecurityUtils.setSecurityManager(securityManager);
  24.         //4.关键对象subject主体
  25.         Subject subject = SecurityUtils.getSubject();
  26.         //5.创建令牌
  27.         UsernamePasswordToken token = new UsernamePasswordToken("zhangsan","123");
  28.         try {
  29.             System.out.println("认证状态"+subject.isAuthenticated());//fasle
  30.             //用户认证
  31.             subject.login(token);
  32.             System.out.println("认证状态"+subject.isAuthenticated());
  33.         }catch (UnknownAccountException e){
  34.             e.printStackTrace();
  35.             System.out.println("认证失败，用户名不存在");
  36.         }catch (IncorrectCredentialsException e){
  37.             e.printStackTrace();
  38.             System.out.println("认证失败，密码错误");
  39.         }
  40.     }
  41. }

1.3.3、常见的异常类型

DisabledAccountException（帐号被禁用）
LockedAccountException（帐号被锁定）
ExcessiveAttemptsException（登录失败次数过多）
ExpiredCredentialsException（凭证过期）等

1.3.4、自定义Realm

通过分析源码可得：

  1. 认证：
  2. 1.最终执行用户名比较是 在SimpleAccountRealm类 的 doGetAuthenticationInfo 方法中完成用户名校验
  3. 2.最终密码校验是在 AuthenticatingRealm类 的 assertCredentialsMatch方法 中
  5. 总结：
  6. AuthenticatingRealm 认证realm doGetAuthenticationInf
  7. AuthorizingRealm 授权realm doGetAuthorizationInfo

自定义Realm的作用：放弃使用.ini文件，使用数据库查询

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

CustomRealm

  1. package com.lms.shiro.realm;
  3. import org.apache.shiro.authc.AuthenticationException;
  4. import org.apache.shiro.authc.AuthenticationInfo;
  5. import org.apache.shiro.authc.AuthenticationToken;
  6. import org.apache.shiro.authc.SimpleAuthenticationInfo;
  7. import org.apache.shiro.authz.AuthorizationInfo;
  8. import org.apache.shiro.realm.AuthorizingRealm;
  9. import org.apache.shiro.subject.PrincipalCollection;
  11. /**
  12.  * 自定义Realm
  13.  */
  14. public class CustomRealm extends AuthorizingRealm {
  15.     //授权
  16.     @Override
  17.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
  18.         System.out.println("==================");
  19.         return null;
  20.     }
  22.     //认证
  23.     @Override
  24.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
  25.         //在token中获取 用户名
  26.         String principal = (String) token.getPrincipal();
  27.         System.out.println(principal);
  29.         //实际开发中应当 根据身份信息使用jdbc mybatis查询相关数据库
  30.         //在这里只做简单的演示
  31.         //假设username,password是从数据库获得的信息
  32.         String username="zhangsan";
  33.         String password="123";
  34.         if(username.equals(principal)){
  35.             //参数1:返回数据库中正确的用户名
  36.             //参数2:返回数据库中正确密码
  37.             //参数3:提供当前realm的名字 this.getName();
  38.             SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(principal,password,this.getName());
  39.             return simpleAuthenticationInfo;
  40.         }
  41.         return null;
  42.     }
  43. }
  1. package com.lms.shiro;
  3. import com.lms.shiro.realm.CustomRealm;
  4. import org.apache.shiro.SecurityUtils;
  5. import org.apache.shiro.authc.IncorrectCredentialsException;
  6. import org.apache.shiro.authc.UnknownAccountException;
  7. import org.apache.shiro.authc.UsernamePasswordToken;
  8. import org.apache.shiro.mgt.DefaultSecurityManager;
  9. import org.apache.shiro.subject.Subject;
  11. /**
  12.  * @Author: 李孟帅
  13.  * @Date: 2021-12-06 17:25
  14.  * @Description:
  15.  */
  16. public class TestCustomRealm {
  17.     public static void main(String[] args) {
  18.         //1.创建安全管理对象 securityManager
  19.         DefaultSecurityManager defaultSecurityManager = new DefaultSecurityManager();
  21.         //2.给安全管理器设置realm（设置为自定义realm获取认证数据）
  22.         defaultSecurityManager.setRealm(new CustomRealm());
  23.         //IniRealm realm = new IniRealm("classpath:shiro.ini");
  25.         //3.给安装工具类中设置默认安全管理器
  26.         SecurityUtils.setSecurityManager(defaultSecurityManager);
  28.         //4.获取主体对象subject
  29.         Subject subject = SecurityUtils.getSubject();
  31.         //5.创建token令牌
  32.         UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123");
  33.         try {
  34.             subject.login(token);//用户登录
  35.             System.out.println("登录成功~~");
  36.         } catch (UnknownAccountException e) {
  37.             e.printStackTrace();
  38.             System.out.println("用户名错误!!");
  39.         }catch (IncorrectCredentialsException e){
  40.             e.printStackTrace();
  41.             System.out.println("密码错误!!!");
  42.         }
  43.     }
  44. }

1.3.5、使用MD5+Salt+Hash进行密码加密

1.3.5.1、MD5算法

作用：一般用来加密或者签名（校验和）
特点：MD5算法不可逆如何内容相同无论执行多少次md5生成结果始终是一致
网络上提供的MD5在线解密一般是用穷举的方法
生成结果：始终是一个16进制32位长度字符串

  1. package com.lut.test;
  3. import org.apache.shiro.crypto.hash.Md5Hash;
  5. public class TestShiroMD5 {
  7.     public static void main(String[] args) {
  9.         //使用md5
  10.         Md5Hash md5Hash = new Md5Hash("123");
  11.         System.out.println(md5Hash.toHex());
  13.         //使用MD5 + salt处理
  14.         Md5Hash md5Hash1 = new Md5Hash("123", "X0*7ps");
  15.         System.out.println(md5Hash1.toHex());
  17.         //使用md5 + salt + hash散列（参数代表要散列多少次，一般是 1024或2048）
  18.         Md5Hash md5Hash2 = new Md5Hash("123", "X0*7ps", 1024);
  19.         System.out.println(md5Hash2.toHex());
  21.     }
  22. }

实际应用：将 盐和散列 后的值存在数据库中，自动realm从数据库取出盐和加密后的值由shiro完成密码校验。

1.3.5.2、自定义md5+salt的realm

  1. package com.lms.shiro.realm;
  3. import org.apache.shiro.authc.AuthenticationException;
  4. import org.apache.shiro.authc.AuthenticationInfo;
  5. import org.apache.shiro.authc.AuthenticationToken;
  6. import org.apache.shiro.authc.SimpleAuthenticationInfo;
  7. import org.apache.shiro.authz.AuthorizationInfo;
  8. import org.apache.shiro.realm.AuthorizingRealm;
  9. import org.apache.shiro.subject.PrincipalCollection;
  10. import org.apache.shiro.util.ByteSource;
  12. /**
  13.  * 使用自定义realm 加入md5 + salt +hash
  14.  */
  15. public class CustomMd5Realm extends AuthorizingRealm {
  17.     //授权
  18.     @Override
  19.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
  20.         return null;
  21.     }
  23.     @Override
  24.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
  25.         //获取 token中的 用户名
  26.         String principal = (String) token.getPrincipal();
  28.         //假设这是从数据库查询到的信息
  29.         String username="zhangsan";
  30.         String password="7268f6d32ec8d6f4c305ae92395b00e8";//加密后
  32.         //根据用户名查询数据库
  33.         if (username.equals(principal)) {
  34.             //参数1:数据库用户名
  35.             //参数2:数据库md5+salt之后的密码
  36.             //参数3:注册时的随机盐
  37.             //参数4:realm的名字
  38.             return new SimpleAuthenticationInfo(principal,
  39.                     password,
  40.                     ByteSource.Util.bytes("@#$*&QU7O0!"),
  41.                     this.getName());
  42.         }
  43.         return null;
  44.     }
  45. }

1.3.5.3、用md5+salt 认证

  1. package com.lms.shiro;
  3. import com.lms.shiro.realm.CustomMd5Realm;
  4. import org.apache.shiro.SecurityUtils;
  5. import org.apache.shiro.authc.IncorrectCredentialsException;
  6. import org.apache.shiro.authc.UnknownAccountException;
  7. import org.apache.shiro.authc.UsernamePasswordToken;
  8. import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
  9. import org.apache.shiro.mgt.DefaultSecurityManager;
  10. import org.apache.shiro.subject.Subject;
  12. public class TestCustomerMd5RealmAuthenicator {
  14.     public static void main(String[] args) {
  16.         //1.创建安全管理器
  17.         DefaultSecurityManager defaultSecurityManager = new DefaultSecurityManager();
  19.         //2.注入realm
  20.         CustomMd5Realm realm = new CustomMd5Realm();
  22.         //3.设置realm使用hash凭证匹配器
  23.         HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
  24.         //声明：使用的算法
  25.         credentialsMatcher.setHashAlgorithmName("md5");
  26.         //声明：散列次数
  27.         credentialsMatcher.setHashIterations(1024);
  28.         realm.setCredentialsMatcher(credentialsMatcher);
  29.         defaultSecurityManager.setRealm(realm);
  31.         //4.将安全管理器注入安全工具
  32.         SecurityUtils.setSecurityManager(defaultSecurityManager);
  34.         //5.通过安全工具类获取subject
  35.         Subject subject = SecurityUtils.getSubject();
  37.         //6.认证
  38.         UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123");
  40.         try {
  41.             subject.login(token);
  42.             System.out.println("登录成功");
  43.         } catch (UnknownAccountException e) {
  44.             e.printStackTrace();
  45.             System.out.println("用户名错误");
  46.         }catch (IncorrectCredentialsException e){
  47.             e.printStackTrace();
  48.             System.out.println("密码错误");
  49.         }
  50.     }
  51. }

1、授权

2.1 授权

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

2.2 关键对象

授权可简单理解为who对what(which)进行How操作：

Who，即主体（Subject），主体需要访问系统中的资源。

What，即资源（Resource)，如系统菜单、页面、按钮、类方法、系统商品信息等。资源包括资源类型和资源实例，比如商品信息为资源类型，类型为t01的商品为资源实例，编号为001的商品信息也属于资源实例。

How，权限/许可（Permission)，规定了主体对资源的操作许可，权限离开资源没有意义，如用户查询权限、用户添加权限、某个类方法的调用权限、编号为001用户的修改权限等，通过权限可知主体对哪些资源都有哪些操作许可。

2.3 授权流程

image.png

2.4 授权方式

  • 基于角色的访问控制

RBAC基于角色的访问控制（Role-Based Access Control）是以角色为中心进行访问控制

  1. if(subject.hasRole("admin")){
  2.    //操作什么资源
  3. }
  • 基于资源的访问控制

RBAC基于资源的访问控制（Resource-Based Access Control）是以资源为中心进行访问控制

  1. if(subject.isPermission("user:update:01")){ //资源实例
  2.   //对资源01用户具有修改的权限
  3. }
  4. if(subject.isPermission("user:update:*")){  //资源类型
  5.   //对 所有的资源 用户具有更新的权限
  6. }

2.5 权限字符串

权限字符串的规则是：资源标识符：操作：资源实例标识符，意思是对哪个资源的哪个实例具有什么操作，“:”是资源/操作/实例的分割符，权限字符串也可以使用*通配符。

例子：

用户创建权限：user:create，或user:create:
用户修改实例001的权限：user:update:001
用户实例001的所有权限：user:：001

2.6 shiro中授权编程实现方式

编程式

  1. Subject subject = SecurityUtils.getSubject();
  2. if(subject.hasRole(“admin”)) {
  3.     //有权限
  4. } else {
  5.     //无权限
  6. }

注解式

  1. @RequiresRoles("admin")
  2. public void hello() {
  3.     //有权限
  4. }

标签式

  1. JSP/GSP 标签：在JSP/GSP 页面通过相应的标签完成：
  2. <shiro:hasRole name="admin">
  3.     <!— 有权限—>
  4. </shiro:hasRole>
  5. 注意: Thymeleaf 中使用shiro需要额外集成!

2.7 代码示例

real

  1. package com.lms.shiro.realm;
  3. import org.apache.shiro.authc.AuthenticationException;
  4. import org.apache.shiro.authc.AuthenticationInfo;
  5. import org.apache.shiro.authc.AuthenticationToken;
  6. import org.apache.shiro.authc.SimpleAuthenticationInfo;
  7. import org.apache.shiro.authz.AuthorizationInfo;
  8. import org.apache.shiro.realm.AuthorizingRealm;
  9. import org.apache.shiro.subject.PrincipalCollection;
  10. import org.apache.shiro.util.ByteSource;
  12. /**
  13.  * 使用自定义realm 加入md5 + salt +hash
  14.  */
  15. public class CustomMd5Realm extends AuthorizingRealm {
  17.     //授权
  18.     @Override
  19.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
  20.         return null;
  21.     }
  23.     @Override
  24.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
  25.         //获取 token中的 用户名
  26.         String principal = (String) token.getPrincipal();
  28.         //假设这是从数据库查询到的信息
  29.         String username="zhangsan";
  30.         String password="7268f6d32ec8d6f4c305ae92395b00e8";//加密后
  32.         //根据用户名查询数据库
  33.         if (username.equals(principal)) {
  34.             //参数1:数据库用户名
  35.             //参数2:数据库md5+salt之后的密码
  36.             //参数3:注册时的随机盐
  37.             //参数4:realm的名字
  38.             return new SimpleAuthenticationInfo(principal,
  39.                     password,
  40.                     ByteSource.Util.bytes("@#$*&QU7O0!"),
  41.                     this.getName());
  42.         }
  43.         return null;
  44.     }
  45. }

授权

  1. package com.lms.shiro;
  3. import com.lms.shiro.realm.CustomMd5Realm;
  4. import org.apache.shiro.SecurityUtils;
  5. import org.apache.shiro.authc.IncorrectCredentialsException;
  6. import org.apache.shiro.authc.UnknownAccountException;
  7. import org.apache.shiro.authc.UsernamePasswordToken;
  8. import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
  9. import org.apache.shiro.mgt.DefaultSecurityManager;
  10. import org.apache.shiro.subject.Subject;
  12. import java.util.Arrays;
  14. public class TestCustomerMd5RealmAuthenicator2 {
  16.     public static void main(String[] args) {
  18.         //1.创建安全管理器
  19.         DefaultSecurityManager defaultSecurityManager = new DefaultSecurityManager();
  21.         //2.注入realm
  22.         CustomMd5Realm realm = new CustomMd5Realm();
  24.         //3.设置realm使用hash凭证匹配器
  25.         HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
  26.         //声明：使用的算法
  27.         credentialsMatcher.setHashAlgorithmName("md5");
  28.         //声明：散列次数
  29.         credentialsMatcher.setHashIterations(1024);
  30.         realm.setCredentialsMatcher(credentialsMatcher);
  31.         defaultSecurityManager.setRealm(realm);
  33.         //4.将安全管理器注入安全工具
  34.         SecurityUtils.setSecurityManager(defaultSecurityManager);
  36.         //5.通过安全工具类获取subject
  37.         Subject subject = SecurityUtils.getSubject();
  39.         //6.认证
  40.         UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123");
  42.         try {
  43.             subject.login(token);
  44.             System.out.println("登录成功");
  45.         } catch (UnknownAccountException e) {
  46.             e.printStackTrace();
  47.             System.out.println("用户名错误");
  48.         }catch (IncorrectCredentialsException e){
  49.             e.printStackTrace();
  50.             System.out.println("密码错误");
  51.         }
  54.         //授权
  55.         if (subject.isAuthenticated()){
  57.             //基于角色权限控制
  58.             System.out.println(subject.hasRole("admin"));
  59.             //基于多角色的权限控制
  60.             System.out.println(subject.hasAllRoles(Arrays.asList("admin", "user")));//true
  61.             System.out.println(subject.hasAllRoles(Arrays.asList("admin", "manager")));//false
  62.             //是否具有其中一个角色
  63.             boolean[] booleans = subject.hasRoles(Arrays.asList("admin", "user", "manager"));
  64.             for (boolean aBoolean : booleans) {
  65.                 System.out.println(aBoolean);
  66.             }
  68.             System.out.println("====这是一个分隔符====");
  70.             //基于权限字符串的访问控制  资源标识符：操作：资源类型
  71.             //用户具有的权限 user:*:01  prodect:*
  72.             System.out.println("权限:"+subject.isPermitted("user:update:01"));
  73.             System.out.println("权限:"+subject.isPermitted("prodect:update:02"));
  75.             //分别具有哪些权限
  76.             boolean[] permitted = subject.isPermitted("user:*:01", "user:update:02");
  77.             for (boolean b : permitted) {
  78.                 System.out.println(b);
  79.             }
  81.             //同时具有哪些权限
  82.             boolean permittedAll = subject.isPermittedAll("prodect:*:01", "prodect:update:03");
  83.             System.out.println(permittedAll);
  85.         }
  87.     }
  88. }