Shiro 框架的MD5加密算法实现原理

直接上代码：该代码可以直接用于项目中做MD5加密，加盐加密，多层散列加密

import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;

public class ShiroMd5 {
    private static final char[] DIGITS = new char[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

    public static void main(String[] args) {
        ShiroMd5 shiroMd5 = new ShiroMd5();
        String pwd = "123456";
        String salt = "saltTest";
        int hashNumber =1;
        String md5SaltHash = shiroMd5.getMd5SaltHash(pwd, salt, hashNumber);
        System.out.println(md5SaltHash);
    }

    /**
     * 加密步骤：
     * @param pwd
     * @param salt
     * @param hashNumber
     * @return
     * 说明：shiro 源码提供的方法支持多种类型变量加密：这里只使用String类型 String pwd, String salt
     */
    public String getMd5SaltHash(String pwd, String salt, int hashNumber){
        if(pwd == null || salt == null) return null;
        try {
            //shiro 官方默认是使用UTF-8编码格式
            byte[] pwdBytes = pwd.getBytes("UTF-8");
            byte[] saltBytes = salt.getBytes("UTF-8");
            //加密规则：先加盐后加密，再多次散列加密
            byte[] hash = hash(pwdBytes, saltBytes, hashNumber);
            //生成的hash 是16位的byte；通过encode 方法对每一位（byte）对应生成两位char
            char[] encode = encode(hash);
            //char 转 String
            return new String(encode);

        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        return null;
    }

    /**
     * 使用JDK 自带的MessageDigest 加密实现
     * @param bytes
     * @param salt
     * @param hashIterations
     * @return
     */
    protected byte[] hash(byte[] bytes, byte[] salt, int hashIterations) {
        //java.security.MessageDigest: jdk 自带的类
        MessageDigest digest = this.getDigest("MD5");
        //加盐：digest.update(salt);
        if (salt != null) {
            digest.reset();
            digest.update(salt);
        }
        //第一次散列加密： digest.digest(bytes);
        byte[] hashed = digest.digest(bytes);
        //多次散列加密：判断
        int iterations = hashIterations - 1;
        for(int i = 0; i < iterations; ++i) {
            digest.reset();
            hashed = digest.digest(hashed);
        }
        return hashed;
    }

    /**
     * 创建MessageDigest 加密类
     * @param algorithmName
     * @return
     */
    protected MessageDigest getDigest(String algorithmName) {
        try {
            return MessageDigest.getInstance(algorithmName);
        } catch (NoSuchAlgorithmException var4) {
            String msg = "No native '" + algorithmName + "' MessageDigest instance available on the current JVM.";
            return null;
        }
    }

    /**
     *
     * @param data
     * @return
     */
    public static char[] encode(byte[] data) {
        int l = data.length;
        char[] out = new char[l << 1];//相当于l 乘于 2，位运算速度更快，更符合机器运算规则
        int i = 0;
        //byte 中的所有值，共16 位，值的范围：-128~127 (2^8)一个字节8位
        System.out.println(Arrays.toString(data));
        //data 为16 位，每个byte 对应生成两个char；最终的md5 是32位。
        //计算方式
        for(int n = 0; i < l; ++i) {
            out[n++] = DIGITS[(0xf0 & data[i]) >>> 4];//"无符号"右移运算 。先“与”运算，再右移三位,最后取DIGITS常量数组中的字符
            out[n++] = DIGITS[0xf & data[i]];//只“与”运算,最后取DIGITS常量数组中的字符
            /*--------------格式化输出看看---------S-----*/
            System.out.print((0xf0 & data[i]) >>> 4);
            System.out.print(" ");
            System.out.print(0xf & data[i]);
            System.out.print(" ");
            //可以看到32位都是正整数，值的范围：0~15，十进制表示16进制的数，通过常量DIGITS[]转成16进制数
            /*--------------格式化输出看看----------E----*/
        }
        System.out.println("\n"+Arrays.toString(out));//最终可以看到32位16进制的字符串：MD5值
        return out;
    }
}

结果输出：