Shiro身份认证&&md5加盐加密

发布于：2023-01-04 ⋅ 阅读:(298) ⋅ 点赞:(0)

目录

一、盐加密

        1.1 数据库密码的发展史

        1.2 盐加密工具类演示

        1.3 利用盐加密实现注册功能

二、Shiro身份认证

        2.1 完成登录的方法（Mapper层、Biz层）

        2.2 完成自定义Realm（重点）

        2.3 Spring与Shiro的整合

        2.4 前端页面

        2.5 测试

一、盐加密

        1.1 数据库密码的发展史

第一阶段：明文密码  123456

第二阶段：md5加密   e10adc3949ba59abbe56e057f20f883e

第三阶段：md5加盐加密

第四阶段：md5加盐加密加次数

加盐加密：根据随机生成的盐（盐可能就是代表某个数字）

                  改变原来的md5加密过的密码，相当于再次加密； 

加次数：加次数就是给这串密码一步步的进行多次加盐加密，极大的提高了密码的安全性；

我们可以看到，数据库密码的发展史让着我们的密码越来越安全，这也极大的保障了用户数据的安全性，就算数据泄露也让别人无处下手。 

        1.2 盐加密工具类演示

                接下来我们就通过一个密码工具类来演示一下加盐加密；

        但是在这之前我们还需要导入工具类需要的Shiro框架的相关pom依赖；

        ① 导入pom依赖：

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

        再一个就是在web.xml中配置shiro过滤器；

       web.xml

<!-- shiro过滤器定义 -->
<filter>
  <filter-name>shiroFilter</filter-name>
  <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
  <init-param>
    <!-- 该值缺省为false,表示生命周期由SpringApplicationContext管理,设置为true则表示由ServletContainer管理 -->
    <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>

         PasswordHelper：加盐加密工具类

package com.leaf.shiro;


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);
    }
}

我们运行写好的main方法，第一次填入正确的用户信息： 

 然后我们再把用户信息输入一个错误的，再次测试：

 演示完成，后面我们就可以利用加盐加密来实现用户的注册功能了。

Leaf就不去测试实现了，这里给你们放上实现的思路：

1.3 利用盐加密实现注册功能

实现思路：

form表单

用户：Leaf

密码：999

传到后台

1、生成随机的盐；

2、利用 999 原始密码 + 生成的随机的盐 得到加密后的密码；

3、执行insert into，添加到数据库。

二、Shiro身份认证

在正式编写代码之前我们还需要做好一些准备工作，例如前面已经完成的导入pom依赖；

我们还需要先来利用逆向生成代码插件生成我们的Mapper层、Model等基础代码。

        2.1 完成登录的方法（Mapper层、Biz层）

                UserMapper.xml

  <!-- 通过用户名进行查询 -->
  <select id="queryUserByUserName" resultType="com.leaf.ssm.model.User" parameterType="java.lang.String" >
    select
    <include refid="Base_Column_List" />
    from t_shiro_user
    where username = #{userName}
  </select>

                UserMapper

package com.leaf.ssm.mapper;

import com.leaf.ssm.model.User;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;

@Repository
public interface UserMapper {
    int deleteByPrimaryKey(Integer userid);

    int insert(User record);

    int insertSelective(User record);

    User selectByPrimaryKey(Integer userid);

    User queryUserByUserName(@Param("userName") String userName);

    int updateByPrimaryKeySelective(User record);

    int updateByPrimaryKey(User record);
}

                 UserBizImpl

package com.leaf.ssm.biz.impl;

import com.leaf.ssm.biz.UserBiz;
import com.leaf.ssm.mapper.UserMapper;
import com.leaf.ssm.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author Leaf
 * @site 2977819715
 * @company 玉渊工作室
 * @create  2022-08-26 3:29
 */
//交给spring进行管理并且指定类名
@Service("userBiz")
public class UserBizImpl implements UserBiz {

    @Autowired
    private UserMapper userMapper;

    @Override
    public int deleteByPrimaryKey(Integer userid) {
        return userMapper.deleteByPrimaryKey(userid);
    }

    @Override
    public int insert(User record) {
        return userMapper.insert(record);
    }

    @Override
    public int insertSelective(User record) {
        return userMapper.insertSelective(record);
    }

    @Override
    public User selectByPrimaryKey(Integer userid) {
        return userMapper.selectByPrimaryKey(userid);
    }

    @Override
    public User queryUserByUserName(String userName) {
        return userMapper.queryUserByUserName(userName);
    }

    @Override
    public int updateByPrimaryKeySelective(User record) {
        return userMapper.updateByPrimaryKeySelective(record);
    }

    @Override
    public int updateByPrimaryKey(User record) {
        return userMapper.updateByPrimaryKey(record);
    }
}

        然后我们编写一个登录的方法：

         ShiroLoginController

package com.leaf.ssm.controller;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;

/**
 * @author Leaf
 * @site 2977819715
 * @company 玉渊工作室
 * @create  2022-08-20 2:25
 */
@Controller
public class ShiroLoginController {

    /**
     * 登录方法
     * @param request
     * @return
     */
    @RequestMapping("/login")
    public String login(HttpServletRequest request){
        try {
            //拿到用户名与密码
            String username = request.getParameter("username");
            String password = request.getParameter("password");
            //拿到令牌
            UsernamePasswordToken token = new UsernamePasswordToken(username,password);
            //拿到登录主体
            Subject subject = SecurityUtils.getSubject();
            //进行登录
            subject.login(token);
            return "main";
        }catch (Exception e){
            request.setAttribute("message","账号密码错误！！！");
            return "login";
        }
    }

    @RequestMapping("/logout")
    public String logout(HttpServletRequest request){
        //拿到登录主体
        Subject subject = SecurityUtils.getSubject();
        //退出方法
        subject.logout();
        return "login";
    }

}

        2.2 完成自定义Realm（重点）

         MyRealm 

package com.leaf.ssm.shiro;

import com.leaf.ssm.biz.UserBiz;
import com.leaf.ssm.model.User;
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.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;
import org.springframework.stereotype.Service;

/**
 * @author Leaf
 * @site 2977819715
 * @company 玉渊工作室
 * @create  2022-08-26 3:37
 */
public class MyRealm extends AuthorizingRealm {

    public UserBiz userBiz;

    public UserBiz getUserBiz() {
        return userBiz;
    }

    public void setUserBiz(UserBiz userBiz) {
        this.userBiz = userBiz;
    }

    /**
     * 授权
     * @param principals
     * @return
     * 替代了昨天的shiro-web.ini
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        return null;
    }

    /**
     * 认证
     * @param token
     * @return
     * @throws AuthenticationException
     * 替代了昨天的shiro.ini
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        //拿到用户名
        String userName = token.getPrincipal().toString();
        //根据用户名查询到用户对象
        User user = userBiz.queryUserByUserName(userName);
        AuthenticationInfo info = new SimpleAuthenticationInfo(
                user.getUsername(),
                user.getPassword(),
                ByteSource.Util.bytes(user.getSalt()),
                this.getName() // realm的名字
        );
        return info;
    }
}

        2.3 Spring与Shiro的整合

                        这一步有两个需要特别注意的点：

① Shiro在加载的时候，Spring框架还没有加载完成；

所以shiro这个时候就还不能交给Spring容器进行管理，也就代表不能使用注解注入使用；

② 因为没有被Spring配置监管，就只能用原始的方法：

在MyRealm中添加userBiz属性的get、set方法，通过配置的方式才可以进行使用。

注：并且要指定bean的Id【通过@Service("具体名字")】；

（在上面的UserBizImpl类中已完成）

因此我们就需要配置一个Shiro的配置文件：

        applicationContext-shiro.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--配置自定义的Realm-->
    <bean id="shiroRealm" class="com.leaf.ssm.shiro.MyRealm">
        <property name="userBiz" ref="userBiz" />
        <!--注意：重要的事情说三次~~~~~~此处加密方式要与用户注册时的算法一致 -->
        <!--注意：重要的事情说三次~~~~~~此处加密方式要与用户注册时的算法一致 -->
        <!--注意：重要的事情说三次~~~~~~此处加密方式要与用户注册时的算法一致 -->
        <!--以下三个配置告诉shiro将如何对用户传来的明文密码进行加密-->
        <property name="credentialsMatcher">
            <bean id="credentialsMatcher" class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
                <!--指定hash算法为MD5-->
                <property name="hashAlgorithmName" value="md5"/>
                <!--指定散列次数为1024次-->
                <property name="hashIterations" value="1024"/>
                <!--true指定Hash散列值使用Hex加密存. false表明hash散列值用用Base64-encoded存储-->
                <property name="storedCredentialsHexEncoded" value="true"/>
            </bean>
        </property>
    </bean>

    <!--注册安全管理器-->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="realm" ref="shiroRealm" />
    </bean>

    <!--Shiro核心过滤器-->
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <!-- Shiro的核心安全接口,这个属性是必须的 -->
        <property name="securityManager" ref="securityManager" />
        <!-- 身份验证失败，跳转到登录页面 -->
        <property name="loginUrl" value="/login"/>
        <!-- 身份验证成功，跳转到指定页面 -->
        <!--<property name="successUrl" value="/index.jsp"/>-->
        <!-- 权限验证失败，跳转到指定页面 -->
        <property name="unauthorizedUrl" value="/unauthorized.jsp"/>
        <!-- Shiro连接约束配置,即过滤链的定义 -->
        <property name="filterChainDefinitions">
            <value>
                <!--
                注：anon，authcBasic，auchc，user是认证过滤器
                    perms，roles，ssl，rest，port是授权过滤器
                -->
                <!--anon 表示匿名访问，不需要认证以及授权-->
                <!--authc表示需要认证 没有进行身份认证是不能进行访问的-->
                <!--roles[admin]表示角色认证，必须是拥有admin角色的用户才行-->
                /user/login=anon
                /user/updatePwd.jsp=authc
                /admin/*.jsp=roles[admin]
                /user/teacher.jsp=perms["user:update"]
                <!-- /css/**               = anon
                 /images/**            = anon
                 /js/**                = anon
                 /                     = anon
                 /user/logout          = logout
                 /user/**              = anon
                 /userInfo/**          = authc
                 /dict/**              = authc
                 /console/**           = roles[admin]
                 /**                   = anon-->
            </value>
        </property>
    </bean>

    <!-- Shiro生命周期，保证实现了Shiro内部lifecycle函数的bean执行 -->
    <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>
</beans>

        并且把它配置到spring的总配置文件中：

        applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 随着后续学习，框架会越学越多，不能将所有的框架配置，放到同一个配置间，否则不便于管理 -->
    <import resource="applicationContext-mybatis.xml"></import>
    <import resource="applicationContext-shiro.xml"></import>
</beans>

        2.4 前端页面

        这里我们还需要测试使用的前端页面，

还是和Leaf昨天的文章提供的一样，需要的自行领取：

链接：百度网盘 请输入提取码
提取码：Leaf

        2.5 测试

登录：

 登录成功：

登录失败： 

结论：doGetAuthenticationInfo认证方法是web层执行subject.login触发的 

OK，今天Leaf的分享就到这里啦，喜欢的可以持续关注噢，下次再见啦！！！ 

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布