精华内容
下载资源
问答
  • 主要介绍了Java消息摘要算法MAC实现与应用,结合完整实例形式分析了java消息摘要算法MAC的概念、原理、实现方法及相关操作注意事项,需要的朋友可以参考下
  • 主要介绍了java实现的MD5摘要算法,结合完整实例形式分析了java实现md5单项加密的具体步骤与相关操作技巧,需要的朋友可以参考下
  • 搜索引擎摘要的选取原则、算法规则一直没有明确的框架或算法,以形成用户查询为中心的动态摘要为出发点,给出了动态摘要算法实现的形式化原则,并具体实现了一种动态摘要算法.与百度搜索引擎的动态摘要相比较,实验结果...
  • 包含java加解密算法(base64,des,3des,aes,pbe,dh,rsa,ElGamal) 包含java摘要算法(md2,md4,md5,sha1,sha2((SHA-224,SHA-256, SHA-384,SHA-512)),mac) 包含签名算法(rsa,dsa,ecdsa)
  • MD5主要是通过特定的hash散列方法将文本信息转换成简短的信息摘要,用以验证信息的完整性。一般用于数字签名。 用Java实现的一个例子。
  • java关于加密的算法demo代码(Base64加密\数字签名\对称加密算法\非对称加密算法\消息摘要算法) JAVA安全实现三种方式: 1.JDK 2.Commons Codec 3.Bouncy Castle 一。非对称加密算法: 1.DH 2.RSA 3.ELGamal 二。...
  • 主要介绍了Python中摘要算法MD5,SHA1简介及应用实例代码,具有一定借鉴价值,需要的朋友可以参考下
  • SHA1摘要算法-C语言

    2020-11-22 16:33:37
    C语言实现SHA1摘要算法。编译环境:VS2010。请参考我的博客https://blog.csdn.net/u013073067/article/details/86597385 分析代码
  • 摘要算法

    千次阅读 2017-04-12 10:18:58
    摘要算法是一种能产生特殊输出格式的算法,这种算法的特点是:无论用户输入多少长度的原始数据,经过计算后输出的密文都是固定长度的,这种算法的原理是根据一定的运算规则对原数据进行某种形式的提取,这种提取就是...
           摘要算法是一种能产生特殊输出格式的算法,这种算法的特点是:无论用户输入多少长度的原始数据,经过计算后输出的密文都是固定长度的,这种算法的原理是根据一定的运算规则对原数据进行某种形式的提取,这种提取就是摘要,被摘要的数据内容与原数据有密切联系,只要原数据稍有改变,输出的“摘要”便完全不同,因此,基于这种原理的算法便能对数据完整性提供较为健全的保障。但是,由于输出的密文是提取原数据经过处理的定长值,所以它已经不能还原为原数据,即消息摘要算法是不可逆的,理论上无法通过反向运算取得原数据内容,因此它通常只能被用来做数据完整性验证。
            如今常用的“消息摘要”算法经历了多年验证发展而保留下来的算法已经不多,这其中包括MD2、MD4、MD5、SHA、SHA-1/256/384/512等。
            常用的摘要算法主要有MD5和SHA1。D5的输出结果为16字节(128位),SHA1的输出结果为20字节(160位)。
             MD5算法: 
            对MD5算法简要的叙述可以为:MD5以512位分组来处理输入的信息,且每一分组又被划分为16个32位子分组,经过了一系列的处理后,算法的输出由四个32位分组组成,将这四个32位分组级联后将生成一个128位散列值。     
    1、首先需要对信息进行填充,使其字节长度对512求余的结果等于448。因此,信息的字节长度(Bits Length)将被扩展至(L-1)*512+448,即(L-1)*64+56个字节(Bytes)。填充的方法如下,在信息的后面填充一个1和无数个0,直到满足上面的条件时才停止用0对信息的填充。
    2、然后在这个结果后面附加一个以64位二进制表示的填充前信息长度。经过这两步的处理,现在的信息字节长度=(L-1)*512+448+64=L*512,即长度恰好是512的整数倍。这样做的原因是为满足后面处理中对信息长度的要求。     
    3、MD5中有4个32位被称作链接变量(Chaining Variable)的整数参数,它们分别为:A=0x01234567,B=0x89abcdef,C=0xfedcba98,D=0x76543210。  它们连接起来作为IV。     
    4、当设置好这四个链接变量后,HMD5开始进入算法的四轮循环运算。
    5、循环的次数是信息中512位信息分组的数目,即L次循环。
             SHA-1算法:
    1、首先需要对信息进行填充,使其字节长度对512求余的结果等于448。因此,信息的字节长度(Bits Length)将被扩展至N*512+448,即N*64+56个字节(Bytes),N为一个正整数。填充的方法如下,在信息的后面填充一个1和无数个0,直到满足上面的条件时才停止用0对信息的填充。 
    2、附加消息长度,与MD5第二步类似,不同的是以大端(最高有效字节/位存储于低地 址字节/位)方式来表示消息被填充前的长度。  
    3、对消息摘要缓冲区初始化,算法使用160比特长的缓冲区来存储中间结果和最终散列值,将缓冲区表示成5个32比特长的寄存器A、B、C、D、E,每个寄存器以大端方式存储数据,初始值为(十六进制,高位字节在前)A=67452301,B=EFCDAB89,C=98BADCFE,D=10325476,E=C3D2E1F0。  
    4、以分组为单位对消息进行处理,每一个分组都经过压缩函数HSHA处理;HSHA有4轮处理过程,每一轮又有20步迭代;4轮处理过程的处理结构一样,所用逻辑函数不同,分别表示为f1、f2、f3、f4;每轮的输入为当前处理的消息分组和缓冲区当前的值,输出仍存放在缓冲区中。最后第四轮的输出与第一轮输入的缓冲区值V相加,相加时将V看做5个32比特的字,每个字与第四轮输出的对应的字按模232相加,相加结果为HMD5的输出。
    5、消息的所有分组均被处理完后,最后一个HSHA的输出即为产生的160位消息摘要。

     
    • 大小: 54.9 KB
    • 大小: 8.8 KB
    展开全文
  • 报文摘要算法

    千次阅读 2021-02-18 17:58:15
    1 报文摘要算法 报文摘要算法是一种将任意长度报文转换成固定长度的报文摘要算法。它具有以下六个特点:能够作用于任意长度的报文;产生有限位数的标识信息;易于实现;具有单向性;具有抗碰撞性;具有高灵敏性。 ...

    1 报文摘要算法

    报文摘要算法是一种将任意长度报文转换成固定长度的报文摘要算法。它具有以下六个特点:能够作用于任意长度的报文;产生有限位数的标识信息;易于实现;具有单向性;具有抗碰撞性;具有高灵敏性。

    1.1 MD5

    1.1.1 添加填充位

    将报文X添加首位为1,其余为0的填充位,填充位长度为Y,使得X与Y的和模512为448。最后加上表示报文长度的64位二进制数,共同组成数据序列。

    1.1.2 分组操作

    将数据序列分割成512位的数据段,对每一段数据段单独进行报文摘要运算,每一段数据段的输入是512的数据段和前一段进行报文摘要运算后的128位结果。

    1.1.3 MD5运算过程

    每一段的512位数据段,它包含4级运算,每一级运算过程进行16次迭代运算。512位数据段被分成16个32位的字,16次迭代运算,输出为32位。4级运算一共产生4*32位=128位结果。
    在这里插入图片描述

    初始运算有一个128位的初始向量,第一个数据段的运算过程的输入是初始向量和第一个数据段,其后数据段的运算过程的输入是512位的数据段和上一段运算的结果。
    在这里插入图片描述

    1.2 SHA-1

    与MD5有相同的填充过程与分组操作。不同的是初始向量与每一段的运算结果是5个32位的字;所以每一级进行20次迭代运算,4级共80次运算。需要将16个32位数据段扩展为80个32位字并分别参加80次迭代运算,但每一级操作使用同一个常量,故常数只需4个。
    二者比较来看,SHA-1的摘要长度是160位,MD5的摘要长度是128位,SHA-1的抗碰撞性更好,同时也使得其计算复杂性高。

    1.3 消息鉴别码(Hashed Message Authentication)

    对消息的报文摘要进行加密运算后得到的结果,用于实现消息完整性检测的附加信息。
    密钥K需要扩充到与数据段长度b相同,变为密钥K+。然后K+与某字节1异或得到S1,K+与某字节2异或得到S0,将S1与报文P串接后进行报文摘要运算,并将运算后的结果扩展为b位并与S0串接,再进行报文摘要运算,最后得到的结果就是HMAC。

    1.4 报文摘要应用

    1.4.1 完整性检测

    应用密钥对报文进行加密并生成附加信息,将附加信息与报文一起发送,接收端可以使用相同密钥进行解密以验证报文在运输过程中是否被修改。

    1.4.2 消息鉴别

    消息鉴别是验证消息M确实是X发送的过程。

    1.4.3 口令安全存储

    算法的单向性使得在知道报文摘要h的情况下,无法找到报文P使得h=MD§。

    1.4.4 数字签名

    数字签名是某个报文的附加信息,该附加消息能够证明签名者的真实性,也能证明签名者是对该报文的确认。

    2 报文摘要算法代码(MD5)

    # -*- coding: utf-8 -*-
    
    import struct
    import math
    import binascii
    
    lrot = lambda x,n: (x << n)|(x >> 32- n)  #循环左移的骚操作
    
    #初始向量
    A, B, C, D = (0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476)
    # A, B, C, D = (0x01234567, 0x89ABCDEF, 0xFEDCBA98, 0x76543210)
    
    #循环左移的位移位数
    r = [   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
            ]
    
    #使用正弦函数产生的位随机数,也就是书本上的T[i]
    T =  [int(math.floor(abs(math.sin(i + 1)) * (2 ** 32))) for i in range(64)]
    
    
    def init_mess(message):
        global A
        global B
        global C
        global D
        A, B, C, D = (0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476)
        # A, B, C, D = (0x01234567, 0x89ABCDEF, 0xFEDCBA98, 0x76543210)
        #将python值转为字节流      Q--Standard size=8  
        length = struct.pack('<Q', len(message)*8)  #原消息长度64位比特的添加格式,bytes类型
        
        while len(message) > 64:
            solve(message[:64])
            message = message[64:]
    
        #长度不足64位消息自行填充
        #因为python3对字符串和二进制数据流做了明确的区分,所以需要先将message的数据类型改为bytes
        message=bytes(message,'utf-8') # type convert to bytes
        message += b'\x80'
        message += b'\x00' * (56 - len(message) % 64)#len=56
        message += length  # len=64
        #print(binascii.b2a_hex(message))
        solve(message[:64])
    
    
    def solve(chunk):
        global A
        global B
        global C
        global D
        #将字节流转为python数据类型  I---Standard size=4  python type=integer
        M = list(struct.unpack('<' + 'I' * 16, chunk))  #分成16个组,I代表1组32位
        #print(M)
        a, b, c, d = A, B, C, D
    
        for i in range(64):  #64轮运算
            if i < 16:  #每一轮运算只用到了b,c,d三个
                f = ( b & c)|((~b) & d)
                flag  = i      #用于标识处于第几组信息
            elif i < 32:
                f = (b & d)|(c & (~d))
                flag = (5 * i +1) %16
            elif i < 48:
                f = (b ^ c ^ d)
                flag  = (3 * i + 5)% 16
            else:
                f = c ^(b |(~d))
                flag  = (7 * i ) % 16
            
            tmp = b + lrot((a + f + T[i] + M[flag])& 0xffffffff,r[i]) #&0xffffffff为了类型转换
            a, b, c, d = d, tmp & 0xffffffff, b, c
            #print(hex(a).replace("0x","").replace("L",""), hex(b).replace("0x","").replace("L","") , hex(c).replace("0x","").replace("L",""), hex(d).replace("0x","").replace("L",""))
        A = (A + a) & 0xffffffff
        B = (B + b) & 0xffffffff
        C = (C + c) & 0xffffffff
        D = (D + d) & 0xffffffff
     
    
    
    def digest():#output长度为16*8=128
        global A
        global B
        global C
        global D
        print(type(struct.pack('<IIII',A,B,C,D)))
        return struct.pack('<IIII',A,B,C,D)
    
    def hex_digest():
        #返回二进制表示的十六进制表示
        # decode()方法以 encoding 指定的编码格式解码字符串,默认为字符串编码
        return binascii.hexlify(digest()).decode()
    
    
    if __name__ == '__main__':
        while True:
            mess = input("请输入你的信息:")
            init_mess(mess)
            out_put = hex_digest()
            print(out_put)
    
    
    展开全文
  • 一、加密算法 1.1加密和解密 1.1.1加密 数据加密的基本过程,就是对原来为明文的文件或数据按某种算法进行处理,使其成为不可读的一段代码,通常称为“密文”。通过这样的途径,来达到 保护数据 不被 非法人窃取...

     

    一、加密算法

    1.1 加密和解密

    1.1.1 加密

    数据加密 的基本过程,就是对原来为明文 的文件或数据按 某种算法 进行处理,使其成为不可读 的一段代码,通常称为“密文”。通过这样的途径,来达到 保护数据 不被 非法人窃取、阅读的目的。

    1.1.2 解密

    加密 的 逆过程 为解密,即将该 编码信息 转化为其 原来数据 的过程。

    1.2对称加密和非对称加密

    加密算法分 对称加密 和 非对称加密,其中对称加密算法的加密与解密密钥相同,非对称加密算法的加密密钥与解密 密钥不同。

    常见的 对称加密 算法主要有 DES3DESAES 等,常见的 非对称算法 主要有 RSADSA 等

     

    1.2.1 对称加密算法

    对称加密算法 是应用较早的加密算法,又称为共享密钥加密算法。在 对称加密算法 中,使用的密钥只有一个,发送 和 接收 双方都使用这个密钥对数据进行 加密 和 解密。这就要求加密和解密方事先都必须知道加密的密钥。

    分析:

    (1)数据加密过程:在对称加密算法中,数据发送方 将 明文 (原始数据) 和 加密密钥 一起经过特殊 加密处理,生成复杂的 加密密文进行发送。

    (2)数据解密过程:数据接收方 收到密文后,若想读取原数据,则需要使用 加密使用的密钥及相同算法的 逆算法 对加密的密文进行解密,才能使其恢复成 可读明文。

     

    1.2.2 非对称加密算法

    非对称加密算法,又称为公开密钥加密算法。它需要两个密钥,一个称为公开密钥 (public key),即 公钥,另一个称为 私有密钥(private key),即 私钥。

    因为 加密 和 解密使用的是两个不同的密钥,所以这种算法称为 非对称加密算法。

    (1)如果使用 公钥对数据 进行加密,只有用对应的 私钥 才能 进行解密。

    (2)如果使用 私钥对数据 进行加密,只有用对应的 公钥 才能 进行解密。

     

    二、摘要算法

    什么是摘要算法呢?摘要算法又称哈希算法、散列算法。它通过一个函数,把任意长度的数据转换为一个长度固定的数据串(通常用16进制的字符串表示)。

    举个例子,你写了一篇文章,内容是一个字符串'how to use pythonhashlib - by Michael',并附上这篇文章的摘要是'2d73d4f15c0db7f5ecb321b6a65e5d6d'。如果有人篡改了你的文章,并发表为'how to usepython hashlib - by Bob',你可以一下子指出Bob篡改了你的文章,因为根据'how to usepython hashlib - by Bob'计算出的摘要不同于原始文章的摘要。

    可见,摘要算法就是通过摘要函数f()对任意长度的数据data计算出固定长度的摘要digest,目的是为了发现原始数据是否被人篡改过。

    摘要算法之所以能指出数据是否被篡改过,就是因为摘要函数是一个单向函数,计算f(data)很容易,但通过digest反推data却非常困难。而且,对原始数据做一个bit的修改,都会导致计算出的摘要完全不同。

    摘要算法 主要有 SHA-1MD5 等。

     

    2.1 MD5是加密吗?

           MD5严格意义上来讲,不是加密算法,而是摘要算法/散列算法,或者叫做哈希算法。

    加密算法的目的,在于别人无法成功查看加密后的数据,并且在需要的时候还可以对数据进行解密来重新查看数据。而 MD5 算法是一种哈希算法,哈希算法的设计目标本身就决定了,它在大多数时候都是不可逆的,即你经过哈希算法得出的数据,无法再经过任何算法还原回去。所以,既然不能将数据还原,也就不能称之为可以解密;既然不能解密,那么哈希的过程自然也就不能称作是「加密」了。

     

    简单理解:

    加密后的消息是完整的;具有解密算法,得到原始数据;

    摘要得到的消息是不完整的;通过摘要的数据,不能得到原始数据。

     

    2.2 MD5算法是如何被破解的?

    2.2.1 何谓破解?

    有很多种方法可以破解,不过需要明确一点,这里所谓的破解,并非把摘要还原成原文。为什么呢?因为固定128位的摘要是有穷的,而原文数量是无穷的,每一个摘要都可以由若干个原文通过Hash得到。

           对于MD5的破解,实际上都属于【碰撞】。比如原文A通过MD5可以生成摘要M,我们并不需要把X还原成A,只需要找到原文B,生成同样的摘要M即可。

    2.2.2 破解之法

    MD5碰撞的方法有很多,主要包括暴力枚举法、字典法、彩虹表法等等。

    暴力枚举法:顾名思义,就是简单粗暴地枚举出所有原文,并计算出它们的哈希值,看看哪个哈希值和给定的信息摘要一致。这种方法虽然简单,但是时间复杂度极高。

           字典发:利用一个巨大的字典,存储尽可能多的原文和对应的哈希值。每次用给定的信息摘要查找字典,即可快速找到碰撞的结果。这样做虽然每次破解速度很快,但是生成字典需要巨大的空间,大约需要4.65PB的存储空间

           对于彩虹表法这个理解起来就比较复杂了,有兴趣的小伙伴可以找资料了解下。

     

    2.3 md5是唯一的吗?

    md5作为数据库中的主键可行吗?这就涉及到一个问题,md5值是唯一的吗?答案是,不唯一。也就是一个原始数据,只对应一个md5值;但是一个md5值,可能对应多个原始数据。

    展开全文
  • 国密SM3摘要算法工具

    2013-11-14 11:20:51
    按照国密SM3算法实现手册,VC++ MFC编译实现的摘要工具。欢迎大家试用
  • 常用几种消息摘要算法

    千次阅读 2019-10-24 11:57:01
    文章目录1、`MD5 (Message Digest algorithm 5 消息摘要算法版本5)`2、`SHA (Secure Hash Algorithm 安全散列算法)`3、`MAC (Hash Message Authentication Code 散列消息鉴别码)` 消息摘要(Message Digest)又称为...

    消息摘要(Message Digest)又称为数字摘要(Digital Digest)。它是一个唯一对应一个消息或文本的固定长度的值,它由一个单向Hash加密函数对消息进行作用而产生。如果消息在途中改变了,则接收者通过对收到消息的新产生的摘要与原摘要比较,就可知道消息是否被改变了。因此消息摘要保证了消息的完整性。

    消息摘要采用单向Hash函数将需加密的明文"摘要"成一串固定位数(如128bit)的密文,这一串密文亦称为数字指纹(Finger Print),它有固定的长度,且不同的明文摘要成密文,其结果总是不同的,而同样的明文其摘要必定一致。这样这串摘要便可成为验证明文是否是“真身”的“指纹”了。

    消息摘要具有不可逆性,在消息摘要生成过程中,会丢失很多原文的信息,而且无法找回。一个好的摘要算法,是极难产生Hash碰撞的,也就是找到另一段明文经计算后产生相同的摘要。

    相关文章:

    • https://www.cnblogs.com/yueshutong/p/11275420.html
    • https://www.iteye.com/blog/snowolf-379860

    有以下几种:

    1、MD5 (Message Digest algorithm 5 消息摘要算法版本5)

    MD是应用非常广泛的一个算法家族,尤其是 MD5(Message-Digest Algorithm 5,消息摘要算法版本5),它由MD2、MD3、MD4发展而来,由Ron Rivest(RSA公司)在1992年提出,目前被广泛应用于数据完整性校验、数据(消息)摘要、数据加密等。MD2、MD4、MD5 都产生16字节(128位)的校验值,一般用32位十六进制数表示。MD2的算法较慢但相对安全,MD4速度很快,但安全性下降,MD5比MD4更安全、速度更快。

    目前在互联网上进行大文件传输时,都要得用MD5算法产生一个与文件匹配的、存储MD5值的文本文件(后缀名为 .md5或.md5sum),这样接收者在接收到文件后,就可以利用与 SFV 类似的方法来检查文件完整性,目前绝大多数大型软件公司或开源组织都是以这种方式来校验数据完整性,而且部分操作系统也使用此算法来对用户密码进行加密,另外,它也是目前计算机犯罪中数据取证的最常用算法。与MD5 相关的工具有很多,如 WinMD5等。

    案例实现:

    /**
     * MD5 测试
     * <br/>
     * 参考:https://www.jianshu.com/p/be000cf837b2
     */
    class Md5Test {
        public static void main(String[] args) throws NoSuchAlgorithmException {
            /* 得注意加密后字符串的大小写 */
            // 待加密字符
            String originalStr = "111111";
            System.out.println(String.format("待加密字符: %s", originalStr));
    
            // 已加密字符
            String alreadyDigestStr = "96E79218965EB72C92A549DD5A330112";
            System.out.println(String.format("已加密字符: %s", alreadyDigestStr));
    
            /* jdk 实现 */
            System.out.println("--------------jdk 实现-----------------");
            // 获取信息摘要对象
            MessageDigest md5 = MessageDigest.getInstance("MD5");
    
            // 完成摘要
            byte[] digest = md5.digest(originalStr.getBytes());
    
            // 将摘要转换成 16 进制字符 (大写)
            String javaMd5Str = DatatypeConverter.printHexBinary(digest);
    
            System.out.println(String.format("%s 加密结果:%s", originalStr, javaMd5Str));
    
            // 匹配验证
            System.out.println(String.format("验证结果:%b", Objects.equals(javaMd5Str, alreadyDigestStr)));
    
            /* Apache commons-codec 实现 */
            System.out.println("---------------Apache commons-codec 实现------------");
            // 小写
            String apacheMd5Str = DigestUtils.md5Hex(originalStr.getBytes()).toUpperCase();
            System.out.println(String.format("%s 加密结果:%s", originalStr, apacheMd5Str));
            System.out.println(String.format("验证结果:%b", Objects.equals(apacheMd5Str, alreadyDigestStr)));
    
            /* spring提供 */
            System.out.println("-----------spring提供-----------");
            // 小写
            String springMd5Str = org.springframework.util.DigestUtils.md5DigestAsHex(originalStr.getBytes()).toUpperCase();
            System.out.println(String.format("%s 加密结果:%s", originalStr, springMd5Str));
            System.out.println(String.format("验证结果:%b", Objects.equals(springMd5Str, alreadyDigestStr)));
        }
    
    }
    

    运行效果如下:

    20191023215219.png

    MD算法可用于密码保护。在用户注册时,利用MD算法取密码的摘要值,存入数据库。在用户登录时,将用户密码再次消息摘要后,与数据库密码进行比较即可得出用户登录结果。流程图如下:

    20191023173151.png

    MD5加密,是属于不可逆的。我们知道正常使用MD5加密技术,同一字符,加密后的16进制数是不变的,自从出现彩虹表,对于公司内部员工来说,可以反查数据,获取不可能的权限,所以出现了salt算法。

    md5加盐算法,代码如下:

    package com.blog.www.util.coder;
    
    import org.apache.commons.codec.digest.DigestUtils;
    
    import java.util.Objects;
    import java.util.Random;
    
    
    /**
     * MD5 加随机盐加密
     * <br/>
     * 参考: <a href='https://www.cnblogs.com/peaceliu/p/7825706.html'>MD5加密+加盐</a>
     * <br/>
     * 基于:{@link DigestUtils}
     * <p>
     * 创建人:leigq <br>
     * 创建时间:2018-12-04 15:42 <br>
     * <p>
     * 修改人: <br>
     * 修改时间: <br>
     * 修改备注: <br>
     * </p>
     */
    public class MD5WithSalt {
    
    	/**
    	 * 生成含有随机盐的加密字符串
    	 * <br>创建人: leigq
    	 * <br>创建时间: 2018-12-04 15:35
    	 * <br>
    	 *
    	 * @param data 待加密的字符
    	 * @return 加密后的字符(含 16 位随机盐),大写
    	 */
    	public static String encrypt(String data) {
    		Random r = new Random();
    		StringBuilder sb = new StringBuilder(16);
    		sb.append(r.nextInt(99999999))
    				.append(r.nextInt(99999999));
    		int len = sb.length();
    		if (len < 16) {
    			for (int i = 0; i < 16 - len; i++) {
    				sb.append("0");
    			}
    		}
    		String salt = sb.toString();
    		String md5WithSaltStr = DigestUtils.md5Hex(data + salt);
    		char[] cs = new char[48];
    		for (int i = 0; i < 48; i += 3) {
    			cs[i] = md5WithSaltStr.charAt(i / 3 * 2);
    			char c = salt.charAt(i / 3);
    			cs[i + 1] = c;
    			cs[i + 2] = md5WithSaltStr.charAt(i / 3 * 2 + 1);
    		}
    		return new String(cs).toUpperCase();
    	}
    
    	/**
    	 * 校验密码是否正确
    	 * <br>创建人: leigq
    	 * <br>创建时间: 2018-12-04 15:38
    	 * <br>
    	 *
    	 * @param data                    待验证的字符(明文)
    	 * @param md5StrContainRandomSalt 加密后的字符(含 16 位随机盐)
    	 * @return 验证结果
    	 */
    	public static boolean verify(String data, String md5StrContainRandomSalt) {
    		// 32 位加密字符(不含盐)
    		char[] cs1 = new char[32];
    		// 16 位的随机盐
    		char[] cs2 = new char[16];
    		for (int i = 0; i < 48; i += 3) {
    			cs1[i / 3 * 2] = md5StrContainRandomSalt.charAt(i);
    			cs1[i / 3 * 2 + 1] = md5StrContainRandomSalt.charAt(i + 2);
    			cs2[i / 3] = md5StrContainRandomSalt.charAt(i + 1);
    		}
    		String salt = new String(cs2);
    		return Objects.equals(DigestUtils.md5Hex(data + salt).toUpperCase(), new String(cs1));
    	}
    }
    
    

    测试:

    /**
     * md5 加随机盐测试
     */
    class MD5WithSaltTest {
    
        public static void main(String[] args) {
            // 待加密字符
            String originalStr = "111111";
    
            // 已加盐加密字符
            String md5WithSaltStr = MD5WithSalt.encrypt(originalStr);
    
            System.out.println(String.format("%s 加密结果:%s", originalStr, md5WithSaltStr));
    
            // 不能直接再次加密验证,因为使用了随机盐,每次加密出来的字符串都不同
            boolean verifyResult = MD5WithSalt.verify(originalStr, md5WithSaltStr);
    
            System.out.println(String.format("验证结果:%b", verifyResult));
        }
    }
    

    测试结果如下:

    20191023215349.png


    2、SHA (Secure Hash Algorithm 安全散列算法)

    SHA(Secure Hash Algorithm)是由美国专门制定密码算法的标准机构——美国国家标准技术研究院(NIST)制定的,SHA系列算法的摘要长度分别为:SHA-1为20字节(160位)、SHA-224为32字节(224位)、SHA-256为32字节(256位)、SHA-384为48字节(384位)、SHA-512为64字节(512位),由于它产生的数据摘要的长度更长,因此更难以发生碰撞,因此较之MD5更为安全,它是未来数据摘要算法的发展方向。由于SHA系列算法的数据摘要长度较长,因此其运算速度与MD5相比,也相对较慢。

    目前SHA1的应用较为广泛,主要应用于CA和数字证书中,另外在目前互联网中流行的BT软件中,也是使用SHA1来进行文件校验的。

    代码实现:

    /**
     * SHA 加密算法测试
     */
    class SHATest {
        public static void main(String[] args) throws NoSuchAlgorithmException {
            // 待加密字符
            String originalStr = "111111";
            System.out.println(String.format("待加密字符: %s", originalStr));
    
            // 已加密字符
            String alreadyDigestStr = "3D4F2BF07DC1BE38B20CD6E46949A1071F9D0E3D";
            System.out.println(String.format("已加密字符: %s", alreadyDigestStr));
    
            /* jdk 实现 */
            // 获取信息摘要对象 (SHA1),另外还有 SHA-224、SHA-256、SHA-384、SHA-512
            MessageDigest md5 = MessageDigest.getInstance("SHA");
    
            // 完成摘要
            byte[] digest = md5.digest(originalStr.getBytes());
    
            // 将摘要转换成 16 进制字符 (大写)
            String javaShaStr = DatatypeConverter.printHexBinary(digest);
    
            System.out.println(String.format("%s 加密结果:%s", originalStr, javaShaStr));
    
            // 匹配验证
            System.out.println(String.format("验证结果:%b", Objects.equals(javaShaStr, alreadyDigestStr)));
    
            /* Apache commons-codec 实现 */
            String apacheShaStr = DigestUtils.sha1Hex(originalStr.getBytes()).toUpperCase();
            System.out.println(String.format("%s 加密结果:%s", originalStr, apacheShaStr));
            System.out.println(String.format("验证结果:%b", Objects.equals(apacheShaStr, alreadyDigestStr)));
    
            /* SHA256 */
            System.out.println(DigestUtils.sha256Hex(originalStr.getBytes()));
            /* SHA384 */
            System.out.println(DigestUtils.sha384Hex(originalStr.getBytes()));
            /* SHA512 */
            System.out.println(DigestUtils.sha512Hex(originalStr.getBytes()));
        }
    }
    

    运行结果如下:

    20191024102910.png

    消息鉴别:

    20191024102954.png


    3、MAC (Hash Message Authentication Code 散列消息鉴别码)

    MAC算法 (Message Authentication Codes消息认证码算法) 含有密钥的散列函数算法,兼容了MD和SHA算法的特性,并在此基础上加上了密钥。因此MAC算法也经常被称作HMAC算法。消息的散列值由只有通信双方知道的密钥来控制。此时Hash值称作MAC。

    经过MAC算法得到的摘要值也可以使用十六进制编码表示,其摘要值得长度与实现算法的摘要值长度相同。例如 HmacSHA算法得到的摘要长度就是SHA1算法得到的摘要长度,都是160位二进制数,换算成十六进制的编码为40位。

    流程分析:

    甲乙双方进行数据交换可以采取如下流程:

    1.甲方向乙方公布摘要算法(就是指定要使用的摘要算法名)

    2.甲乙双方按照约定构造密钥,双方拥有相同的密钥(一般是一方构造密钥后通知另外一方,此过程不需要通过程序实现,就是双方约定个字符串,但是这个字符串可不是随便设定的,也是通过相关算法获取的)

    3.甲方使用密钥对消息做摘要处理,然后将消息和生成的摘要消息一同发送给乙方

    4.乙方收到消息后,使用甲方已经公布的摘要算法+约定好的密钥 对收到的消息进行摘要处理。然后比对自己的摘要消息和甲方发过来的摘要消息。甄别消息是否是甲方发送过来的。

    代码实现:

    /**
     * MAC 算法测试
     */
    class MacTest {
    	public static void main(String[] args) throws NoSuchAlgorithmException, DecoderException, InvalidKeyException {
    		// 待加密字符
    		String originalStr = "111111";
    		System.out.println(String.format("待加密字符: %s", originalStr));
    
    		// 已加密字符
    		String alreadyDigestStr = "74B31DBA9E16CCF752B294A18271BC6A";
    		System.out.println(String.format("已加密字符: %s", alreadyDigestStr));
    
    		/* jdk 实现 */
    		// 初始化 KeyGenerator, jdk 提供 HmacMD5、HmacSHA1、HmacSHA256、HmacSHA384和 HmacSHA512 四种算法
    //		KeyGenerator keyGenerator = KeyGenerator.getInstance("HmacMD5");
    		// 产生密钥
    //		SecretKey secretKey = keyGenerator.generateKey();
    		// 默认密钥
    		// byte[] defaultKey = secretKey.getEncoded();
    		// 自定义密钥
    		byte[] myKey = Hex.decodeHex(new char[]{'a','a','a','a','a','a','a','a','a','a'});
    		// 还原密钥
    		SecretKey restoreSecretKey = new SecretKeySpec(myKey, "HmacMD5");
    		// 实例化 MAC
    		Mac mac = Mac.getInstance(restoreSecretKey.getAlgorithm());
    		// 初始化 MAC
            mac.init(restoreSecretKey);
            //执行摘要
    		byte[] hmacMD5Bytes = mac.doFinal(originalStr.getBytes());
            String encodeHexString = Hex.encodeHexString(hmacMD5Bytes).toUpperCase();
            System.out.println(String.format("%s 加密结果:%s", originalStr, encodeHexString));
    		System.out.println(String.format("验证结果:%b", Objects.equals(encodeHexString, alreadyDigestStr)));
    
    
    		/* apache 实现 */
            // HmacMD5
            HmacUtils hmacMd5 = new HmacUtils(HmacAlgorithms.HMAC_MD5, myKey);
            String apacheHmacMd5 = hmacMd5.hmacHex(originalStr.getBytes()).toUpperCase();
            System.out.println(String.format("%s 加密结果:%s", originalStr, apacheHmacMd5));
            System.out.println(String.format("验证结果:%b", Objects.equals(apacheHmacMd5, alreadyDigestStr)));
    
            // HmacSHA1
            HmacUtils hmacSha1 = new HmacUtils(HmacAlgorithms.HMAC_SHA_1, KeyGenerator.getInstance(HmacAlgorithms.HMAC_SHA_1.getName()).generateKey().getEncoded());
            String apacheHmacHex1 = hmacSha1.hmacHex(originalStr.getBytes()).toUpperCase();
            System.out.println(String.format("%s 加密结果:%s", originalStr, apacheHmacHex1));
    
            // HmacSHA256
            HmacUtils hmacSha256 = new HmacUtils(HmacAlgorithms.HMAC_SHA_256, KeyGenerator.getInstance(HmacAlgorithms.HMAC_SHA_256.getName()).generateKey().getEncoded());
            String apacheHmacSha256 = hmacSha256.hmacHex(originalStr.getBytes()).toUpperCase();
            System.out.println(String.format("%s 加密结果:%s", originalStr, apacheHmacSha256));
    
            // HmacSHA384 , 类似上面
    
            // HmacSHA512, 类似上面
        }
    }
    

    运行结果:

    20191024114046.png

    上面这几种摘要算法,可谓是非可逆加密,就是不可解密的加密方法。我们通常只把他们作为加密的基础。单纯的以上三种的加密并不可靠。

    展开全文
  • 消息摘要算法

    千次阅读 2019-04-11 20:37:47
    定义: 消息摘要算法又称为散列算法,其核心在于散列函数的...消息摘要算法主要分为三大类:MD(Message Digest,消息摘要算法)、SHA(Secure Hash Algorithm,安全散列算法)和MAC(Message Authentication Code,消息认...
  • 散列算法(也叫:摘要算法): 特点:① 无论输入的消息有多长,计算出来的消息摘要的长度总是固定的。② 消息摘要看起来是“随机的”。这些比特看上去是胡乱的杂凑在一起的。③ 一般地,只要输入的消息不同,对其...
  • 从 RFC3174 文档摘抄下来的 SHA1 摘要算法的C语言实现代码
  • MD5消息摘要算法

    2018-05-24 17:57:02
    MD5(中文名为消息摘要算法第五版)为计算机安全领域广泛使用的一种散列函数,用以提供消息的完整性保护。
  • 这篇文章主要介绍了Python hashlib常见摘要算法详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 Python的hashlib提供了常见的摘要算法,如MD5,SHA1等等 ...
  • 消息摘要算法包含MD、SHA和MAC共3大系列,常用于验证数据的完整性,是数字签名算法的核心算法。数字签名算法常用函数为散列函数,用于数据完整性校验。任何消息经过散列函数处理后,都会获得唯一的散列值。这一过程...
  • 这次我们乘胜追击,介绍【信息摘要算法】, 通过本文的阅读,你可以了解到以下知识: 什么是信息摘要算法? 常见的信息摘要算法有哪些以及它们的特性和区别是什么? 信息摘要算法的应用场景有哪些? 什么是信息...
  • MD5 摘要算法应用详解

    千次阅读 2020-06-23 23:37:32
      MD5是典型的消息摘要算法,是广泛使用的消息摘要算法之一,更是消息摘要算法首要代表。其前身包括MD2、MD4。MD算法家族针对源数据会产生一个128位的消息摘要。在一般应用场景下,会将128二进制摘要信息转换为...
  • 本篇文章主要介绍了Java实现MD5消息摘要算法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • JAVA摘要算法

    万次阅读 2017-12-09 09:10:58
    数据摘要算法是密码学算法中非常重要的一个分支,它通过对所有数据提取指纹信息以实现数据签名、数据完整性校验等功能,由于其不可逆性,有时候会被用做敏感信息的加密。数据摘要算法也被称为哈希(Hash)算法、散列...
  • 三种摘要算法的简单介绍

    万次阅读 2018-03-19 10:36:26
    原文地址:http://blog.csdn.net/u013991521/article/details/48193953介绍:消息摘要算法分为三类:MD(Message Digest):消息摘要SHA(Secure Hash Algorithm):...验证数据的完整性消息摘要算法是有关于数字签名...
  • 主要介绍了MAC算法之消息摘要算法HmacMD5的实现的相关资料,这里提供实例,帮助大家学习理解这部分知识,需要的朋友可以参考下
  • 信息摘要算法

    2015-05-30 14:39:03
    用于网络安全的信息摘要算法,SHA信息摘要算法
  • MD5摘要算法文档.txt

    2021-01-23 19:14:32
    此文本文档是MD5信息摘要算法的描述文档(英文),描述了MD5摘要算法的具体实现,并提供了C语言参考代码,此文件是本人为防止原链接失效而作的备份,如不想消耗积分,请查看此文档的原链接...
  • 使用消息摘要算法提升密码安全性

    千次阅读 2020-12-28 16:38:57
    而处理密码字符串更换进行加密时,不可以使用加密算法,加密算法一般来讲保证的是传输过程中数据的安全性,加密算法的特点为可逆向推导运算,对于密码来说,逆向运算...所以需要存储的数据不应该使用加密算法。 在实
  • # 基础版,不依赖环境 import time import base64 import hashlib class Token_hander(): def __init__(self,out_time): self.out_time = out_... 摘要算法加密 :param str: 待加密字符串 :return: 加密后的字符串

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 131,739
精华内容 52,695
关键字:

摘要算法