【密码学】MD5原理与java实现

最新推荐文章于 2023-06-11 09:15:00 发布
最新推荐文章于 2023-06-11 09:15:00 发布
阅读量2.7k 收藏 10
点赞数
分类专栏： 密码学 文章标签： MD5 密码 加密 哈希

来自：点击打开链接，百度百科

                   

一、概述

1.概念

        MD5即Message Digest Algorithm 5（中文名为消息摘要算法第五版），是计算机广泛使用的杂凑算法之一（又译摘要算法、哈希算法），用以提供消息的完整性保护。主要是通过特定的hash方法将文本信息转换成简短的信息摘要，压缩+加密+hash算法的结合体，是绝对不可逆的。

2.特征

（1）压缩性：任意长度输入，得到固定长度输出（一般取128bit）。
        （2）易计算：从原数据计算出MD5值很容易。
        （3）防篡改：对原数据进行任何改动，哪怕只修改1个字节，所得到的MD5值大概率不同。
        （4）难碰撞：由于使用哈希函数，无法避免碰撞，但碰撞是小概率事件。

3.应用

       （1）完整性验证：由特征三知，可验证消息在传输过程中是否被篡改。
        （2）数字签名：在上一条的基础上，如果再有一个第三方的认证机构，用MD5还可以防止文件作者的“抵赖”，这就是所谓的数字签名应用。

        （3）登陆认证：在操作系统中，系统把用户注册的密码的MD5值存储在系统文件中，用户登录时哪用户登陆密码的MD5值去匹配验证。

二、过程

         MD5以512位分组来处理输入数据，且每一分组又被划分为16个32位子分组，经过了一系列的处理后，算法的输出由四个32位分组组成，将这四个32位分组级联后将生成一个128位散列值。


1.填充

         如果输入信息的长度(bit)对512求余的结果不等于448，就需要填充使得对512求余的结果等于448。填充的方法是填充一个1和n个0。填充完后，信息的长度就为N*512+448(bit)； 用64位来存储填充前信息长度。这64位加在第一步结果的后面，这样信息长度就变为N*512+448+64=(N+1)*512位。

2.初始化向量IV

初始化：A=0x01234567，B=0x89ABCDEF，C=0xFEDCBA98，D=0x76543210（内存中吗，大端模式）。

 实际值：A=0x67452301，B=0xEFCDAB89，C=0x98BADCFE，D=0x10325476

H0=A0B0C0D0

3.循环轮（哈希过程）

一共有N+1次循环，每次循环4轮，每次循环处理16个32位子分组共512位数据。

对于每次循环中的四轮：

（1）首先认识四个轮函数：(&是与,|是或,~是非,^是异或) 

   F(X,Y,Z)=(X&Y)|((~X)&Z)
   G(X,Y,Z)=(X&Z)|(Y&(~Z))
   H(X,Y,Z)=X^Y^Z
   I(X,Y,Z)=Y^(X|(~Z))

（2）a、b、c、d、初值分别为Hi-1=（A、B、C、D、）i-1；Mj表示第j(j从0到15)个子分组;ti是固定常量；s是一个随机变量

   FF(a,b,c,d,Mj,s,ti)表示a=b+((a+F(b,c,d)+Mj+ti)<<<s)
   GG(a,b,c,d,Mj,s,ti)表示a=b+((a+G(b,c,d)+Mj+ti)<<<s)
   HH(a,b,c,d,Mj,s,ti)表示a=b+((a+H(b,c,d)+Mj+ti)<<<s)
   II(a,b,c,d,Mj,s,ti)表示a=b+((a+I(b,c,d)+Mj+ti)<<<s)

（3）四轮运算

第一轮
a=FF(a,b,c,d,M0,7,0xd76aa478)
 b=FF(d,a,b,c,M1,12,0xe8c7b756)
 c=FF(c,d,a,b,M2,17,0x242070db)
 d=FF(b,c,d,a,M3,22,0xc1bdceee)
 a=FF(a,b,c,d,M4,7,0xf57c0faf)
 b=FF(d,a,b,c,M5,12,0x4787c62a)
 c=FF(c,d,a,b,M6,17,0xa8304613)
 d=FF(b,c,d,a,M7,22,0xfd469501)
 a=FF(a,b,c,d,M8,7,0x698098d8)
 b=FF(d,a,b,c,M9,12,0x8b44f7af)
 c=FF(c,d,a,b,M10,17,0xffff5bb1)
 d=FF(b,c,d,a,M11,22,0x895cd7be)
 a=FF(a,b,c,d,M12,7,0x6b901122)
 b=FF(d,a,b,c,M13,12,0xfd987193)
 c=FF(c,d,a,b,M14,17,0xa679438e)
 d=FF(b,c,d,a,M15,22,0x49b40821)

第二轮
a=GG(a,b,c,d,M1,5,0xf61e2562)
 b=GG(d,a,b,c,M6,9,0xc040b340)
 c=GG(c,d,a,b,M11,14,0x265e5a51)
 d=GG(b,c,d,a,M0,20,0xe9b6c7aa)
 a=GG(a,b,c,d,M5,5,0xd62f105d)
 b=GG(d,a,b,c,M10,9,0x02441453)
 c=GG(c,d,a,b,M15,14,0xd8a1e681)
 d=GG(b,c,d,a,M4,20,0xe7d3fbc8)
 a=GG(a,b,c,d,M9,5,0x21e1cde6)
 b=GG(d,a,b,c,M14,9,0xc33707d6)
 c=GG(c,d,a,b,M3,14,0xf4d50d87)
 d=GG(b,c,d,a,M8,20,0x455a14ed)
 a=GG(a,b,c,d,M13,5,0xa9e3e905)
 b=GG(d,a,b,c,M2,9,0xfcefa3f8)
 c=GG(c,d,a,b,M7,14,0x676f02d9)
 d=GG(b,c,d,a,M12,20,0x8d2a4c8a)

第三轮
a=HH(a,b,c,d,M5,4,0xfffa3942)
 b=HH(d,a,b,c,M8,11,0x8771f681)
 c=HH(c,d,a,b,M11,16,0x6d9d6122)
 d=HH(b,c,d,a,M14,23,0xfde5380c)
 a=HH(a,b,c,d,M1,4,0xa4beea44)
 b=HH(d,a,b,c,M4,11,0x4bdecfa9)
 c=HH(c,d,a,b,M7,16,0xf6bb4b60)
 d=HH(b,c,d,a,M10,23,0xbebfbc70)
 a=HH(a,b,c,d,M13,4,0x289b7ec6)
 b=HH(d,a,b,c,M0,11,0xeaa127fa)
 c=HH(c,d,a,b,M3,16,0xd4ef3085)
 d=HH(b,c,d,a,M6,23,0x04881d05)
 a=HH(a,b,c,d,M9,4,0xd9d4d039)
 b=HH(d,a,b,c,M12,11,0xe6db99e5)
 c=HH(c,d,a,b,M15,16,0x1fa27cf8)
 d=HH(b,c,d,a,M2,23,0xc4ac5665)

第四轮
a=II(a,b,c,d,M0,6,0xf4292244)
 b=II(d,a,b,c,M7,10,0x432aff97)
 c=II(c,d,a,b,M14,15,0xab9423a7)
 d=II(b,c,d,a,M5,21,0xfc93a039)
 a=II(a,b,c,d,M12,6,0x655b59c3)
 b=II(d,a,b,c,M3,10,0x8f0ccc92)
 c=II(c,d,a,b,M10,15,0xffeff47d)
 d=II(b,c,d,a,M1,21,0x85845dd1)
 a=II(a,b,c,d,M8,6,0x6fa87e4f)
 b=II(d,a,b,c,M15,10,0xfe2ce6e0)
 c=II(c,d,a,b,M6,15,0xa3014314)
 d=II(b,c,d,a,M13,21,0x4e0811a1)
 a=II(a,b,c,d,M4,6,0xf7537e82)
 b=II(d,a,b,c,M11,10,0xbd3af235)
 c=II(c,d,a,b,M2,15,0x2ad7d2bb)
 d=II(b,c,d,a,M9,21,0xeb86d391)

这四轮结束后：Hi=Hi-1  + (a,b,c,d)用于下一512分组abcd的初值。


三、java实现与使用

1.实现

public class MD5{
    /*
    *四个初始变量
    */
    private final int A=0x67452301;
    private final int B=0xefcdab89;
    private final int C=0x98badcfe;
    private final int D=0x10325476;
    /*
    *ABCD的临时变量
    */
    private int Atemp,Btemp,Ctemp,Dtemp;
     
    /*
    *常量ti
    *公式:floor(abs(sin(i+1))×(2pow32)
    */
    private final int K[]={
        0xd76aa478,0xe8c7b756,0x242070db,0xc1bdceee,
        0xf57c0faf,0x4787c62a,0xa8304613,0xfd469501,0x698098d8,
        0x8b44f7af,0xffff5bb1,0x895cd7be,0x6b901122,0xfd987193,
        0xa679438e,0x49b40821,0xf61e2562,0xc040b340,0x265e5a51,
        0xe9b6c7aa,0xd62f105d,0x02441453,0xd8a1e681,0xe7d3fbc8,
        0x21e1cde6,0xc33707d6,0xf4d50d87,0x455a14ed,0xa9e3e905,
        0xfcefa3f8,0x676f02d9,0x8d2a4c8a,0xfffa3942,0x8771f681,
        0x6d9d6122,0xfde5380c,0xa4beea44,0x4bdecfa9,0xf6bb4b60,
        0xbebfbc70,0x289b7ec6,0xeaa127fa,0xd4ef3085,0x04881d05,
        0xd9d4d039,0xe6db99e5,0x1fa27cf8,0xc4ac5665,0xf4292244,
        0x432aff97,0xab9423a7,0xfc93a039,0x655b59c3,0x8f0ccc92,
        0xffeff47d,0x85845dd1,0x6fa87e4f,0xfe2ce6e0,0xa3014314,
        0x4e0811a1,0xf7537e82,0xbd3af235,0x2ad7d2bb,0xeb86d391};
    /*
    *向左位移数,计算方法未知
    */
    private final int s[]={7,12,17,22,7,12,17,22,7,12,17,22,7,
        12,17,22,5,9,14,20,5,9,14,20,5,9,14,20,5,9,14,20,
        4,11,16,23,4,11,16,23,4,11,16,23,4,11,16,23,6,10,
        15,21,6,10,15,21,6,10,15,21,6,10,15,21};
     
     
    /*
    *初始化函数
    */
    private void init(){
        Atemp=A;
        Btemp=B;
        Ctemp=C;
        Dtemp=D;
    }
    /*
    *移动一定位数
    */
    private    int    shift(int a,int s){
        return(a<<s)|(a>>>(32-s));//右移的时候，高位一定要补零，而不是补充符号位
    }
    /*
    *主循环
    */
    private void MainLoop(int M[]){
        int F,g;
        int a=Atemp;
        int b=Btemp;
        int c=Ctemp;
        int d=Dtemp;
        for(int i = 0; i < 64; i ++){
            if(i<16){
                F=(b&c)|((~b)&d);
                g=i;
            }else if(i<32){
                F=(d&b)|((~d)&c);
                g=(5*i+1)%16;
            }else if(i<48){
                F=b^c^d;
                g=(3*i+5)%16;
            }else{
                F=c^(b|(~d));
                g=(7*i)%16;
            }
            int tmp=d;
            d=c;
            c=b;
            b=b+shift(a+F+K[i]+M[g],s[i]);
            a=tmp;
        }
        Atemp=a+Atemp;
        Btemp=b+Btemp;
        Ctemp=c+Ctemp;
        Dtemp=d+Dtemp;
     
    }
    /*
    *填充函数
    *处理后应满足bits≡448(mod512),字节就是bytes≡56（mode64)
    *填充方式为先加一个1,其它位补0
    *最后加上64位的原来长度
    */
    private int[] add(String str){
        int num=((str.length()+8)/64)+1;//以512位，64个字节为一组
        int strByte[]=new int[num*16];//64/4=16，所以有16个整数
        for(int i=0;i<num*16;i++){//全部初始化0
            strByte[i]=0;
        }
        int    i;
        for(i=0;i<str.length();i++){
            strByte[i>>2]|=str.charAt(i)<<((i%4)*8);//一个整数存储四个字节，小端序
        }
        strByte[i>>2]|=0x80<<((i%4)*8);//尾部添加1
        /*
        *添加原长度，长度指位的长度，所以要乘8，然后是小端序，所以放在倒数第二个,这里长度只用了32位
        */
        strByte[num*16-2]=str.length()*8;
            return strByte;
    }
    /*
    *调用函数
    */
    public String getMD5(String source){
        init();
        int strByte[]=add(source);
        for(int i=0;i<strByte.length/16;i++){
        int num[]=new int[16];
        for(int j=0;j<16;j++){
            num[j]=strByte[i*16+j];
        }
        MainLoop(num);
        }
        return changeHex(Atemp)+changeHex(Btemp)+changeHex(Ctemp)+changeHex(Dtemp);
     
    }
    /*
    *整数变成16进制字符串
    */
    private String changeHex(int a){
        String str="";
        for(int i=0;i<4;i++){
            str+=String.format("%2s", Integer.toHexString(((a>>i*8)%(1<<8))&0xff)).replace(' ', '0');
 
        }
        return str;
    }
    /*
    *单例
    */
    private static MD5 instance;
    public static MD5 getInstance(){
        if(instance==null){
            instance=new MD5();
        }
        return instance;
    }
     
    private MD5(){};
     
    public static void main(String[] args){
        String str=MD5.getInstance().getMD5("");
        System.out.println(str);
    }
}

2.使用
调用java API,与上面实现无关，彩虹表和加盐将在下一篇博客中讲解（MD5的使用和概念特性掌握，原理作了解） 
package EncryptAndDecrypt;

import java.security.MessageDigest;
import java.util.Random;

/**
 * 散列加密之32位哈希值的MD5算法，调用JDK里的API
 *ps：准确来说散列加密不是加密算法，因为它是不可逆的（只能加密，不能解密）
 */
public class MyMD5 {

    private static char[] hex = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};

    public static void main(String[] args) throws Exception {
        String input = "123456";
        System.out.println("MD5加密" + "\n"
                         + "明文：" + input + "\n"
                         + "无盐密文：" + MD5WithoutSalt(input));
        System.out.println("带盐密文：" + MD5WithSalt(input,0));
    }

    /**
    *@Author: DavidHuang
    *@Time: 2018/5/11 14:55
    *@return:
    *@params: [inputStr] 输入明文
    *@Descrption: 不加盐MD5
    */
    public static String MD5WithoutSalt(String inputStr) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");//申明使用MD5算法,更改参数为"SHA"就是SHA算法了
            return byte2HexStr(md.digest(inputStr.getBytes()));//哈希计算,转换输出
        } catch (Exception e) {
            e.printStackTrace();
            return e.toString();
        }

    }

    /**
    *@Author: DavidHuang
    *@Time: 2018/5/11 14:47
    *@return:
    *@params: [inputStr, type] inputStr是输入的明文;type是处理类型，0表示注册存hash值到库时，1表示登录验证时
    *@Descrption:  MD5加盐，盐的获取分两种情况;输入明文加盐；输出密文带盐(将salt存储到hash值中)
    */
    public static String MD5WithSalt(String inputStr, int type) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");//申明使用MD5算法,更改参数为"SHA"就是SHA算法了

            String salt = null;
            if (type == 0) {//注册存hash值到库时，new salt
                salt = salt();
            } else if (type == 1) {//登录验证时，使用从库中查找到的hash值提取出的salt
                String queriedHash=null;//从库中查找到的hash值
                salt=getSaltFromHash(queriedHash);
            }

            String inputWithSalt = inputStr + salt;//加盐，输入加盐
            String hashResult = byte2HexStr(md.digest(inputWithSalt.getBytes()));//哈希计算,转换输出
            System.out.println("加盐密文："+hashResult);

            /*将salt存储到hash值中，用于登陆验证密码时使用相同的盐*/
            char[] cs = new char[48];
            for (int i = 0; i < 48; i += 3) {
                cs[i] = hashResult.charAt(i / 3 * 2);
                cs[i + 1] = salt.charAt(i / 3);//输出带盐，存储盐到hash值中;每两个hash字符中间插入一个盐字符
                cs[i + 2] = hashResult.charAt(i / 3 * 2 + 1);
            }
            hashResult = new String(cs);
            return hashResult;
        } catch (Exception e) {
            e.printStackTrace();
            return e.toString();
        }
    }


    /**
     * @Author: DavidHuang
     * @Time: 2018/5/10 21:14
     * @return: salt
     * @params:
     * @Descrption: 自定义简单加盐，是一个随机生成的长度为16的字符串，每一个字符是随机的十六进制字符
     */
    public static String salt() {
        Random random = new Random();
        StringBuilder sb = new StringBuilder(16);
        for (int i = 0; i < sb.capacity(); i++) {
            sb.append(hex[random.nextInt(16)]);
        }
        return sb.toString();
    }

    /**
     * @Author: DavidHuang
     * @Time: 2018/5/11 14:08
     * @return: 十六进制字符串
     * @params: [bytes]
     * @Descrption: 将字节数组转换成十六进制字符串
     */
    private static String byte2HexStr(byte[] bytes) {
        /**
         *@Author: DavidHuang
         *@Time: 19:41 2018/5/10
         *@return: java.lang.String
         *@params:  * @param bytes
         *@Descrption:
         */
        int len = bytes.length;
        StringBuffer result = new StringBuffer();
        for (int i = 0; i < len; i++) {
            byte byte0 = bytes[i];
            result.append(hex[byte0 >>> 4 & 0xf]);
            result.append(hex[byte0 & 0xf]);
        }
        return result.toString();
    }


    /**
    *@Author: DavidHuang
    *@Time: 2018/5/11 14:32
    *@return: 提取的salt
    *@params: [hash] 3i byte带盐的hash值,带盐方法与MD5WithSalt中相同
    *@Descrption:  从库中查找到的hash值提取出的salt
    */
    public static String getSaltFromHash(String hash){
        StringBuilder sb=new StringBuilder();
        char [] h=hash.toCharArray();
        for(int i=0;i<hash.length();i+=3){
            sb.append(h[i+1]);
        }
        return sb.toString();
    }

}

一次运行结果：

MD5加密
明文：123456
无盐密文：E10ADC3949BA59ABBE56E057F20F883E
加盐密文：650B429350224E94B150C2DDFE0C2D19
带盐密文：61505B4029F35C028240E994BF15F0CF2DCDFDE0BC2CD1C9


逍遥剑臣
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
Java 消息摘要MessageDigest简介
02-21
消息摘要是JAVA安全体系中最基本的安全摘要算法，是数字签名基础，可以保证数据的完整性但不能保证数据的私密性。通过本系列的学习，可以了解消息摘要的原理，了解常用的消息摘要引擎类，本课程给出来最基本的消息摘要的引擎类示例，便于用户学习和使用消息摘要编程
MD5算法原理及其实现
热门推荐
不很正派的专栏
01-16 12万+
MD5讯息摘要演算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码杂凑函数，可以产生出一个128位元（16位元组）的散列值（hash value），用于确保信息传输完整一致。
常见的加密算法原理与实现：MD5加密
仙路尽头谁为峰
06-11 1万+
系列三：MD5加密一、基本介绍二、加密原理2.1、处理原文2.2、设置初始值2.3、循环加工2.4、拼接结果 一、基本介绍 MD5加密算法，其全称是Message-Digest Algorithm 5，通常被称为信息摘要算法，所谓的信息摘要就是把明文内容按一定规则生成一段哈希（hash）值，即得到这段明文内容的信息摘要。利用MD5可以基于任意长度的明文字符串生成128位的哈希值，结果唯一且不可逆，因此MD5经常被用于防止信息被篡改、数字签名、以及对明文进行加密等场景。 二、加密原理 MD5算法加密的过程分为
MD5算法的实现、安全性和优化
qq_19843217的博客
06-11 1093
MD5算法是一种常见的摘要算法，用于将任意长度的消息转换为一个固定长度的哈希值。该算法由美国麻省理工学院的Ronald L. Rivest在1991年设计，因其快速、高效和广泛应用而成为流行的摘要算法。MD5算法可以将任意长度的消息（字节序列）转换为128位的哈希值。这个哈希值通常表示为32个十六进制数字，通常为32字节。MD5算法的核心思想是输入数据“摘要”的方式，通过将消息作为输入，对其进行一系列非线性、复杂的比特转换操作，最终得到唯一的哈希值。
MD5算法原理及实现
qq_53633989的博客
09-15 6126
MD5由美国密码学家罗纳德·李维斯特（Ronald Linn Rivest）设计，于1992年公开，是一个典型的密码散列函数，MD5方法将所有的文件看作为一个个的文本文件，通过不可逆 的字符串变化算法可以将输入的报文信息转化生成一个128位的散列值。如果报文的内容发生变化，通过哈希算法得到的散列值也会相应地发生变化。a) MD5的过程是不可逆的b)MD5具有高度的离散性c)产生固定长度的输出结果d)抵制弱碰撞性。
JAVA中使用MD5加密实现密码加密
08-30
本篇文章主要介绍JAVA中使用MD5加密实现密码加密，很多地方都要存储用户密码,这里整理了详细的代码,有需要的小伙伴可以参考下
java实现Md5加盐加密算法
10-26
对接接口时用到的一种常用加密算法，常用于验证签名，使用shiro-all-1.4.1.jar，可自行下载
java加密MD5实现及密码验证代码实例
08-25
主要介绍了java加密MD5实现及密码验证代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
哈希函数的冲突-md5碰撞算法原理-密码学
10-26
差分攻击2004-199王小云（MD4、MD5、HAVAL-128和RIPEMD四个国际著名密码算法的破译结果）差分攻击是通过比较分析有特定区别的明文在通过加密后变化传播情况来攻击密码算法的。
java生成md5密码加盐
07-10
java、springboot生成加盐md5密码
密码学中AES\DES\MD5\SHA1\RSA加密流程的JAVA实现
01-07
用eclipse实现生成消息认证码、数字签名、加密流程及其可视化，包含可执行文件和源代码、流程演示，可以分开利用标题所述功能也可串在一起实现完整的保密消息传输过程。
密码学MD5&RSA&DES源代码.
08-22
密码学MD5&RSA&DES源代码.
密码学-MD5 基于java源代码
12-09
密码学MD5算法的java源代码，其中包含详细注释，以及几组测试数据，程序能够正确运行。
密码学：MD5+Mysql
05-28
可以用在用户登录注册是对密码进行加密解密
现代密码学_原理与协议.pdf
06-25
现代密码学—原理与协议，讲解了各种现代密码学，非常详细 《现代密码学:原理与协议》内容简介：密码学在确保数据的私密性和完整性，以及计算机网络的安全性方面扮演了关键角色。乔纳森·卡茨和耶胡达·林德尔所著...
MessageDigest简介
baobaoupup
12-23 862
本文博客原文 参考文章：http://blog.sina.com.cn/s/blog_4f36423201000c1e.html 一、概述 java.security.MessageDigest类用于为应用程序提供信息摘要算法的功能，如 MD5 或 SHA 算法。简单点说就是用于生成散列码。信息摘要是安全的单向哈希函数，它接收任意大小的数据，输出固定长度的哈希值。关于信...
密码学_MD5算法
qq_40442137的博客
01-10 550
简单记录MD5原理
MD5加密概述，原理及实现
weixin_69965075的博客
03-31 2925
消息分以512位为一分组进行处理，每一个分组进行上述4轮共64次计算后，将A，B，C，D分别加上计算得到的a，b，c，d。当做新的A，B，C，D，并将这4个变量赋值给a,b,c,d再进行下一分组的运算。把常用的密码先MD5处理，并将数据存储起来，然后跟需要查询的MD5结果匹配，这时就有可能通过匹配的MD5得到明文，所以有些简单的MD5码是反查到加密前原文的。(初次使用的a,b,c,d为A,B,C,D的值，而Mi,s,tj根据下面的数值进行使用，可认为是常量，)每轮使用FF，GG，HH，II中的一种操作；
密码学系列之五：MD5、SHA1——一文搞懂哈希函数
聚集机器学习、信息安全
10-24 6997
Hash 函数是密码学的一个重要分支,它将任意长度的输入变换为固定长度输出，是一种的不可逆的单向密码体制。Hash函数在数字签名和消息完整性检测等方面有广泛的应用。本文将首先介绍 Hash 函数的基本概念，然后详述 MD5、SHA1算法，并对其安全性进行分析，最后介绍基于 Hash函数的消息认证码。
java登陆密码md5加密
最新发布
08-24
在Java中，可以使用不同的方法对登录密码进行MD5加密。一种常见的方法是使用md5算法对密码进行加密。可以在代码中导入相关的库，如`import java.util.Scanner;`和`import java.util.Random;`，然后使用相应的方法对...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值