Shiro框架02权限认证+MD5加盐加密+散列1024+Hex/Base64(源码)

蔚落 2024-04-01 16:15 15阅读 0赞

**目录**

1.导入基于Shiro的数据库脚本

2.引入依赖(shiro-1.4.1)

3.自定义Realm

注1：体系结构见“shiro提供的realm.png”

编辑

4.Spring与Shiro集成

5.修改web.xml文件，添加shiroFilter的配置

6.实现Shiro身份认证登录

7.盐加密（MD5+散列1024+Hex/Base64）

--------------------

## 1.导入基于Shiro的数据库脚本 ##

> t\_sys\_user：用户信息表，例如：zs,ls,ww  
> t\_sys\_role：用户角色表，例如：普通员工,x项目经理等等  
> t\_sys\_permission 权限信息表，例如：做自己的工作、做自己的工作及管理整个部门，做自己的工作及管理这个公司  
> t\_sys\_user\_role 用户角色表  
> t\_sys\_role\_permission 角色权限表 （一个角色对应多个权限）

![29e8068715864468ba3624e80c1a1e51.png][]

关联关系：

用户与角色 角色与权限

用户-------------------------------------------------------角色--------------------------------------------权限

## 2.引入依赖(shiro-1.4.1) ##

<dependency>
          <groupId>org.apache.shiro</groupId>
          <artifactId>shiro-core</artifactId>
          <version>1.4.1</version>
        </dependency>
        <dependency>
          <groupId>org.apache.shiro</groupId>
          <artifactId>shiro-web</artifactId>
          <version>1.4.1</version>
        </dependency>
        <dependency>
          <groupId>org.apache.shiro</groupId>
          <artifactId>shiro-spring</artifactId>
          <version>1.4.1</version>
        </dependency>

## 3.自定义Realm ##

> Shiro从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；可以把Realm看成DataSource，即安全数据源。
> 
> **最基础的是Realm接口**
> 
> **CachingRealm负责缓存处理**
> 
> **AuthenticationRealm负责认证**
> 
> **AuthorizingRealm负责授权。**
> 
> **通常自定义的realm继承AuthorizingRealm**
> 
> **AuthorizationInfo：授权信息  
> AuthenticationInfo：认证信息**

#### ![eae3e2439a4842a0838bf10801701285.png][] ####

#### **注1：体系结构见“shiro提供的realm.png”** ####

### ![75ca37779f664a6aaed556aab0930393.png][] ###

### 4.Spring与Shiro集成 ###

**1) 配置自定义Realm**

<bean id="shiroRealm" class="com.zking.ssm.book.shiro.ShiroRealm">
          //注入UserService实现类，通过账号密码登录时实现基于Shiro身份认证识别
          
          //盐加密算法配置，详见7.2
      </bean>

**2) 注册安全管理器**

> 将自定义的Realm设置到Shiro的SecurityManager中，在Shiro授权和认证时使用自定义的Realm数据源进行校验

3) 配置Shiro核心过滤器

> Shiro核心过滤器用于拦截请求，通过给定的授权认证机制对用户访问身份和权限进行认证识别

<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
            
            <property name="securityManager" ref="securityManager" />
            
            <property name="loginUrl" value="/home/index.shtml"/>
            
            <property name="successUrl" value="/index.jsp"/>
            
            <property name="unauthorizedUrl" value="/noauthorizeUrl.jsp"/>
            
            <property name="filterChainDefinitions">
                <value>
                    
                    
                    /login=anon
                    /book/**=authc
                   
                </value>
            </property>
        </bean>

**filterChainDefinitions Shiro过滤链定义类型：**

> (1) anon，authcBasic，auchc，user是认证过滤器  
> (2) perms，roles，ssl，rest，port是授权过滤器
> 
>   
>   
>   
>   
>   
>   
>   
>

**4) 配置Shiro生命周期**

<bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>

## 5.修改web.xml文件，添加shiroFilter的配置 ##

<filter>
            <filter-name>shiroFilter</filter-name>
            <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
            <init-param>
                
                <param-name>targetFilterLifecycle</param-name>
                <param-value>true</param-value>
            </init-param>
        </filter>
        <filter-mapping>
            <filter-name>shiroFilter</filter-name>
            <url-pattern>/*</url-pattern>
        </filter-mapping>

## 6.实现Shiro身份认证登录 ##

//用户登录
      public String login(请求参数){
         ...
         //关键代码
         Subject subject=SecurityUtils.getSubject(); 
         UsernamepasswordToken token=new UsernamepasswordToken(
             账号,
             密码
         );
         subject.login(token);
         ...
      }
     
      //退出登录
      public String logout(){
         ...
         //关键代码
         Subject subject=SecurityUtils.getSubject(); 
         subject.logout();
         ...
      }

## 7.盐加密（MD5+散列1024+Hex/Base64） ##

**生成加密密码PasswordHelper类（盐加密）**

package com.zking.ssm.util;
    
    
    import org.apache.shiro.crypto.RandomNumberGenerator;
    import org.apache.shiro.crypto.SecureRandomNumberGenerator;
    import org.apache.shiro.crypto.hash.SimpleHash;
    
    /**
     * 用于shiro权限认证的密码工具类
     */
    public class PasswordHelper {
    
        /**
         * 随机数生成器
         */
        private static RandomNumberGenerator randomNumberGenerator = new SecureRandomNumberGenerator();
    
        /**
         * 指定hash算法为MD5
         */
        private static final String hashAlgorithmName = "md5";
    
        /**
         * 指定散列次数为1024次，即加密1024次
         */
        private static final int hashIterations = 1024;
    
        /**
         * true指定Hash散列值使用Hex加密存. false表明hash散列值用用Base64-encoded存储
         */
        private static final boolean storedCredentialsHexEncoded = true;
    
        /**
         * 获得加密用的盐
         *
         * @return
         */
        public static String createSalt() {
            return randomNumberGenerator.nextBytes().toHex();
        }
    
        /**
         * 获得加密后的凭证
         *
         * @param credentials 凭证(即密码)
         * @param salt        盐
         * @return
         */
        public static String createCredentials(String credentials, String salt) {
            SimpleHash simpleHash = new SimpleHash(hashAlgorithmName, credentials,
                    salt, hashIterations);
            return storedCredentialsHexEncoded ? simpleHash.toHex() : simpleHash.toBase64();
        }
    
    
        /**
         * 进行密码验证
         *
         * @param credentials        未加密的密码
         * @param salt               盐
         * @param encryptCredentials 加密后的密码
         * @return
         */
        public static boolean checkCredentials(String credentials, String salt, String encryptCredentials) {
            return encryptCredentials.equals(createCredentials(credentials, salt));
        }
    
        public static void main(String[] args) {
            //盐
            String salt = createSalt();
            System.out.println(salt);
            System.out.println(salt.length());
            //凭证+盐加密后得到的密码
            String credentials = createCredentials("123456", salt);
            System.out.println(credentials);
            System.out.println(credentials.length());
            boolean b = checkCredentials("123456", salt, credentials);
            System.out.println(b);
        }
    }

**修改applicationContext-shirod的自定义Realm配置，增加以下：**

<property name="credentialsMatcher">
         <bean id="credentialsMatcher" class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
            
            <property name="hashAlgorithmName" value="md5"/>
            
            <property name="hashIterations" value="1024"/>    
            
            <property name="storedCredentialsHexEncoded" value="true"/>
         </bean>
      </property>

以上就是今天的分享

[29e8068715864468ba3624e80c1a1e51.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/fe426d7ee3024e19a00bec6dea70d7f4.png
[eae3e2439a4842a0838bf10801701285.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/fb8a2603bed24631945034de97863e48.png
[75ca37779f664a6aaed556aab0930393.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/8e6cf1d30a0848fe910990fc8b085f0b.png