1、MD算法的基的概念

   MD5算法是典型的消息摘要算法，其前身有MD2、MD3和MD4算法，它由MD4、MD3和MD2算法改进而来。不论是哪一种MD算法，它们都需 要获得一个随机长度的信息并产生一个128位的信息摘要。如果将这个128位的二进制摘要信息换算成十六进制，可以得到一个32位的字符串，故我们见到的 大部分MD5算法的数字指纹都是32为十六进制的字符串。

2、MD算法的发展史

2.1 MD2算法

   1989年，著名的非对称算法RSA发明人之一----麻省理工学院教授罗纳德.李维斯特开发了MD2算法。这个算法首先对信息进行数据补位，使信 息的字节长度是16的倍数。再以一个16位的检验和做为补充信息追加到原信息的末尾。最后根据这个新产生的信息计算出一个128位的散列值，MD2算法由 此诞生。

2.2 MD4算法

   1990年，罗纳德.李维斯特教授开发出较之MD2算法有着更高安全性的MD4算法。在这个算法中，我们仍需对信息进行数据补位。不同的是，这种补 位使其信息的字节长度加上448个字节后成为512的倍数（信息字节长度mod 512 =448）。此外，关于MD4算的处理和MD2算法有很大的差别。但最终仍旧会获得一个128为的散列值。MD4算法对后续消息摘要算法起到了推动作用， 许多比较有名的消息摘要算法都是在MD4算法的基础上发展而来的，如MD5、SHA-1、RIPE-MD和HAVAL算法等。

2.3 MD5算法

   1991年，继MD4算法后，罗纳德.李维斯特教授开发了MD5算法，将MD算法推向成熟。MD5算法经MD2、MD3和MD4算法发展而来，算法复杂程度和安全强度打打提高，但浙西MD算法的最终结果都是产生一个128位的信息摘要。这也是MD系列算法的特点。MD5算法的算法特点如下：
（1）压缩性：任意长度的数据，算出的MD5值长度都是固定的。
（2）容易计算：从原数据计算出MD5值很容易。
（3）抗修改性：对原数据进行任何改动，哪怕只修改1个字节，所得到的MD5值都有很大区别。
（4）弱抗碰撞：已知原数据和其MD5值，想找到一个具有相同MD5值的数据（即伪造数据）是非常困难的。
（5）强抗碰撞：想找到两个不同的数据，使它们具有相同的MD5值，是非常困难的。

2.4、MD5破解方面

   在破解md5方面，最常用的方法是“跑字典”，有两种方法得到字典，一种是日常搜集的用做密码的字符串表，另一种是用排列组合方法生成的，先用MD5程序计算出这些字典项的MD5值，然后再用目标的MD5值在这个字典中检索。我们假设密码的最大长度为8位字节（8 Bytes），同时密码只能是字母和数字，共26+26+10=62个字节，排列组合出的字典的项数则是P（62,1）+P（62,2）….+P（62,8），那也已经是一个很天文的数字了，存储这个字典就需要TB级的磁盘阵列，而且这种方法还有一个前提，就是能获得目标账户的密码MD5值的情况下才可以。

所以总体而言，md5加密是十分安全的，即使有一些瑕疵，但并不影响具体的使用，外加md5是免费的，所以它的应用还是十分广泛的。

3、MD5算法应用

3.1、Md5 密码存储加盐

    MD5算法，可以用来保存用户的密码信息。为了更好的保存，可以在保存的过程中，加入盐。/在保存用户密码的时候，盐可以利用生成的随机数。可以将密码结合MD5加盐，生成的数据摘要和盐保存起来 。以便于下次用户验证使用。在用户表里面，也保存salt。

3.2、Md5 文件完整性校验

    每个文件都可以用MD5验证程序算出一个固定的MD5值，是独一无二的。一般来说，开发方会在软件发布时预先算出文件的MD5值，如果文件被盗用，加了木马或者被篡改版权，那么它的MD5值也随之改变，也就是说我们对比文件当前的MD5值和它标准的MD5值来检验它是否正确和完整。
（1）例如网盘中的秒传4G文件，可以使用用户需要上传的文件进行Md5运算，判断与服务器中是否存在该文件，如果存在只需添加文件索引，不存在再真正上传。
（2）例如自动升级的客户端，判断下载的程序安装包是否完整，可以计算文件的MD5值，与服务器端计算的Md5值进行比对。

4、MD5算法实现

4.1 JDK算法实现

package lzf.cipher.jdk;

import java.nio.charset.Charset;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
 * @author Java小工匠
 */
public class JdkMd5Utils {

    public static final Charset UTF8 = Charset.forName("UTF-8");
    public static final int SI = 8;
    public static final int EI = 24;

    // MD5 小写16位
    public static String md5L16(String str) {
        return md5L32(str.getBytes(UTF8)).substring(SI, EI);
    }

    // MD5 大写16位
    public static String md5U16(String str) {
        return md5U32(str.getBytes(UTF8)).substring(SI, EI);
    }

    // MD5 小写16位
    public static String md5L16(byte[] bytes) {
        return md5L32(bytes).substring(SI, EI);
    }

    // MD5 大写16位
    public static String md5U16(byte[] bytes) {
        return md5U32(bytes).substring(SI, EI);
    }

    // =========================================================
    // 默认Md5算法
    public static String md5(String str) {
        return md5U32(str);
    }

    // 默认Md5算法
    public static String md5(byte[] bytes) {
        return md5U32(bytes);
    }

    // MD5 小写32位
    public static String md5L32(String str) {
        return md5L32(str.getBytes(UTF8));
    }

    // MD5 小写32位
    public static String md5L32(byte[] bytes) {
        try {
            // 1、获得MD5摘要算法的 MessageDigest 对象
            MessageDigest digest = MessageDigest.getInstance("md5");
            // 2、使用指定的字节更新摘要
            digest.update(bytes);
            // 3、获得密文
            byte[] rsBytes = digest.digest();
            // 4、把密文转换成十六进制的字符串形式
            return encodeHex(rsBytes, true);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e.getMessage(), e);
        }
    }

    // MD5 大写32位
    public static String md5U32(String str) {
        return md5U32(str.getBytes(UTF8));
    }

    // MD5 大写32位
    public static String md5U32(byte[] bytes) {
        try {
            MessageDigest digest = MessageDigest.getInstance("md5");
            digest.update(bytes);
            byte[] rsBytes = digest.digest();
            return encodeHex(rsBytes, false);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e.getMessage(), e);
        }
    }

    // 字节数组转16 进制
    // 数据准16进制编码
    public static String encodeHex(final byte[] data) {
        return encodeHex(data, true);
    }

    // 数据转16进制编码
    public static String encodeHex(final byte[] data, final boolean toLowerCase) {
        final char[] DIGITS_LOWER = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
        final char[] DIGITS_UPPER = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
        final char[] toDigits = toLowerCase ? DIGITS_LOWER : DIGITS_UPPER;
        final int l = data.length;
        final char[] out = new char[l << 1];
        // two characters form the hex value.
        for (int i = 0, j = 0; i < l; i++) {
            out[j++] = toDigits[(0xF0 & data[i]) >>> 4];
            out[j++] = toDigits[0x0F & data[i]];
        }
        return new String(out);
    }

    public static void main(String[] args) {
        String str = "Java小工匠";
        String low16 = md5L16(str);
        String upper16 = md5U16(str);
        String low32 = md5L32(str);
        String upper32 = md5U32(str);
        System.out.println("16位小写:" + low16);
        System.out.println("16位大写:" + upper16);
        System.out.println("32位小写:" + low32);
        System.out.println("32位大写:" + upper32);
    }
}

4.2 CC 算法实现

package lzf.cipher.cc;

import java.nio.charset.Charset;

import org.apache.commons.codec.digest.DigestUtils;

/**
 * @author Java小工匠
 */
public class CCMd5Utils {

    public static final Charset UTF8 = Charset.forName("UTF-8");
    public static final int SI = 8;
    public static final int EI = 24;

    // MD5 小写16位
    public static String md5L16(String str) {
        return md5L32(str.getBytes(UTF8)).substring(SI, EI);
    }

    // MD5 大写16位
    public static String md5U16(String str) {
        return md5U32(str.getBytes(UTF8)).substring(SI, EI);
    }

    // MD5 小写16位
    public static String md5L16(byte[] bytes) {
        return md5L32(bytes).substring(SI, EI);
    }

    // MD5 大写16位
    public static String md5U16(byte[] bytes) {
        return md5U32(bytes).substring(SI, EI);
    }

    // =========================================================
    // 默认Md5算法
    public static String md5(String str) {
        return md5U32(str);
    }

    // 默认Md5算法
    public static String md5(byte[] bytes) {
        return md5U32(bytes);
    }

    // MD5 小写32位
    public static String md5L32(String str) {
        return md5L32(str.getBytes(UTF8));
    }

    // MD5 小写32位
    public static String md5L32(byte[] bytes) {
        return DigestUtils.md5Hex(bytes);
    }

    // MD5 大写32位
    public static String md5U32(String str) {
        return md5U32(str.getBytes(UTF8));
    }

    // MD5 大写32位
    public static String md5U32(byte[] bytes) {
        return DigestUtils.md5Hex(bytes).toUpperCase();
    }

    public static void main(String[] args) {
        String str = "Java小工匠";
        String low16 = md5L16(str);
        String upper16 = md5U16(str);
        String low32 = md5L32(str);
        String upper32 = md5U32(str);
        System.out.println("16位小写:" + low16);
        System.out.println("16位大写:" + upper16);
        System.out.println("32位小写:" + low32);
        System.out.println("32位大写:" + upper32);
    }
}

4.2 BC 算法实现

package lzf.cipher.bc;

import java.nio.charset.Charset;

import org.bouncycastle.crypto.Digest;
import org.bouncycastle.crypto.digests.MD5Digest;
import org.bouncycastle.util.encoders.Hex;

/**
 * @author Java小工匠
 */
public class BCMd5Utils {

    public static final Charset UTF8 = Charset.forName("UTF-8");
    public static final int SI = 8;
    public static final int EI = 24;

    // MD5 小写16位
    public static String md5L16(String str) {
        return md5L32(str.getBytes(UTF8)).substring(SI, EI);
    }

    // MD5 大写16位
    public static String md5U16(String str) {
        return md5U32(str.getBytes(UTF8)).substring(SI, EI);
    }

    // MD5 小写16位
    public static String md5L16(byte[] bytes) {
        return md5L32(bytes).substring(SI, EI);
    }

    // MD5 大写16位
    public static String md5U16(byte[] bytes) {
        return md5U32(bytes).substring(SI, EI);
    }

    // =========================================================
    // 默认Md5算法
    public static String md5(String str) {
        return md5U32(str);
    }

    // 默认Md5算法
    public static String md5(byte[] bytes) {
        return md5U32(bytes);
    }

    // MD5 小写32位
    public static String md5L32(String str) {
        return md5L32(str.getBytes(UTF8));
    }

    // MD5 小写32位
    public static String md5L32(byte[] data) {
        Digest digest = new MD5Digest();
        digest.update(data, 0, data.length);
        byte[] rsData = new byte[digest.getDigestSize()];
        digest.doFinal(rsData, 0);
        return Hex.toHexString(rsData);
    }

    // MD5 大写32位
    public static String md5U32(String str) {
        return md5U32(str.getBytes(UTF8));
    }

    // MD5 大写32位
    public static String md5U32(byte[] bytes) {
        return md5L32(bytes).toUpperCase();
    }

    // MD4 算法
    public static String md4(byte[] data) {
        Digest digest = new MD5Digest();
        digest.update(data, 0, data.length);
        byte[] rsData = new byte[digest.getDigestSize()];
        digest.doFinal(rsData, 0);
        return Hex.toHexString(data);
    }

    public static void main(String[] args) {
        String str = "Java小工匠";
        String low16 = md5L16(str);
        String upper16 = md5U16(str);
        String low32 = md5L32(str);
        String upper32 = md5U32(str);
        String md4 = md4(str.getBytes());
        System.out.println("16位小写:" + low16);
        System.out.println("16位大写:" + upper16);
        System.out.println("32位小写:" + low32);
        System.out.println("32位大写:" + upper32);
        System.out.println("md4:" + md4);
    }
}

如果读完觉得有收获的话，欢迎点赞、关注、加公众号【小工匠技术圈】

个人公众号，欢迎关注，查阅更多精彩历史！