md5 订阅
MD5信息摘要算法(英语:MD5 Message-Digest Algorithm),一种被广泛使用的密码散列函数,可以产生出一个128位(16字节)的散列值(hash value),用于确保信息传输完整一致。MD5由美国密码学家罗纳德·李维斯特(Ronald Linn Rivest)设计,于1992年公开,用以取代MD4算法。这套算法的程序在 RFC 1321 标准中被加以规范。1996年后该算法被证实存在弱点,可以被加以破解,对于需要高度安全性的数据,专家一般建议改用其他算法,如SHA-2。2004年,证实MD5算法无法防止碰撞(collision),因此不适用于安全性认证,如SSL公开密钥认证或是数字签名等用途。 展开全文
MD5信息摘要算法(英语:MD5 Message-Digest Algorithm),一种被广泛使用的密码散列函数,可以产生出一个128位(16字节)的散列值(hash value),用于确保信息传输完整一致。MD5由美国密码学家罗纳德·李维斯特(Ronald Linn Rivest)设计,于1992年公开,用以取代MD4算法。这套算法的程序在 RFC 1321 标准中被加以规范。1996年后该算法被证实存在弱点,可以被加以破解,对于需要高度安全性的数据,专家一般建议改用其他算法,如SHA-2。2004年,证实MD5算法无法防止碰撞(collision),因此不适用于安全性认证,如SSL公开密钥认证或是数字签名等用途。
信息
别    称
摘要算法
提出者
罗纳德·李维斯特
应用学科
信息技术,计算机科学
中文名
消息摘要算法
外文名
Message Digest Algorithm MD5
提出时间
1992年
MD5发展历史
1992年8月,罗纳德·李维斯特向互联网工程任务组(IETF)提交了一份重要文件,描述了这种算法的原理。由于这种算法的公开性和安全性,在90年代被广泛使用在各种程序语言中,用以确保资料传递无误等 [1]  。MD5由MD4、MD3、MD2改进而来,主要增强算法复杂度和不可逆性。MD5算法因其普遍、稳定、快速的特点,仍广泛应用于普通数据的加密保护领域 [2]  。Rivest在1989年开发出MD2算法 [3]  。在这个算法中,首先对信息进行数据补位,使信息的字节长度是16的倍数。然后,以一个16位的校验和追加到信息末尾,并且根据这个新产生的信息计算出散列值。后来,Rogier和Chauvaud发现如果忽略了校验和MD2将产生冲突。MD2算法加密后结果是唯一的(即不同信息加密后的结果不同) [4]  。为了加强算法的安全性,Rivest在1990年又开发出MD4算法 [3]  。MD4算法同样需要填补信息以确保信息的比特位长度减去448后能被512整除(信息比特位长度mod 512 = 448)。然后,一个以64位二进制表示的信息的最初长度被添加进来。信息被处理成512位damgard/merkle迭代结构的区块,而且每个区块要通过三个不同步骤的处理。Den boer和Bosselaers以及其他人很快的发现了攻击MD4版本中第一步和第三步的漏洞。Dobbertin向大家演示了如何利用一部普通的个人电脑在几分钟内找到MD4完整版本中的冲突(这个冲突实际上是一种漏洞,它将导致对不同的内容进行加密却可能得到相同的加密后结果) [5]  。1991年,Rivest开发出技术上更为趋近成熟的MD5算法。它在MD4的基础上增加了"安全带"(safety-belts)的概念。虽然MD5比MD4复杂度大一些,但却更为安全。这个算法很明显的由四个和MD4设计有少许不同的步骤组成。在MD5算法中,信息-摘要的大小和填充的必要条件与MD4完全相同。Den boer和Bosselaers曾发现MD5算法中的假冲突(pseudo-collisions),但除此之外就没有其他被发现的加密后结果了 [3]  。
收起全文
精华内容
下载资源
问答
  • md5
    千次阅读
    2022-01-28 17:00:13

    MD5的全称是Message-Digest Algorithm 5,90年代初发明

    MD5以512位分组来处理输入的信息,且每一分组又被划分为16个32位子分组,经过了一系列的处理后,算法的输出由四个32位分组组成,将这四个32位分组级联后将生成一个128位散列值,它是一个不可逆的字符串变换算法

    一个文件可以生成唯一的MD5值,你只要改变里面某个字符,那么都会导致MD5值改变,常用于加密、校验、数字签名等等

    最近项目中实时视频监控用到了MD5算法向后台请求监控编号,具体用法如下

    1. script标签直接引入

    <script src="https://cdn.bootcdn.net/ajax/libs/blueimp-md5/2.19.0/js/md5.js"></script>

        最新地址blueimp-md5 (v2.19.0) - JavaScript MD5 implementation. | BootCDN - Bootstrap 中文网开源项目免费 CDN 加速服务

    2. 新建本地js文件,因为公司是内网所以我用的这个办法,文件放在src里面了

    var hexcase = 0;  
    var b64pad  = ""; 
    var chrsz   = 8;  
    
    function md5_vm_test () {
      return hex_md5("abc") == "900150983cd24fb0d6963f7d28e17f72";
    }
    
    function core_md5 (x, len) {
      x[len >> 5] |= 0x80 << ((len) % 32);
      x[(((len + 64) >>> 9) << 4) + 14] = len;
      var a =  1732584193;
      var b = -271733879;
      var c = -1732584194;
      var d =  271733878;
      for(var i = 0; i < x.length; i += 16) {
        var olda = a;
        var oldb = b;
        var oldc = c;
        var oldd = d;
    
        a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);
        d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);
        c = md5_ff(c, d, a, b, x[i+ 2], 17,  606105819);
        b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);
        a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);
        d = md5_ff(d, a, b, c, x[i+ 5], 12,  1200080426);
        c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);
        b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);
        a = md5_ff(a, b, c, d, x[i+ 8], 7 ,  1770035416);
        d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);
        c = md5_ff(c, d, a, b, x[i+10], 17, -42063);
        b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);
        a = md5_ff(a, b, c, d, x[i+12], 7 ,  1804603682);
        d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);
        c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);
        b = md5_ff(b, c, d, a, x[i+15], 22,  1236535329);
        a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);
        d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);
        c = md5_gg(c, d, a, b, x[i+11], 14,  643717713);
        b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);
        a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);
        d = md5_gg(d, a, b, c, x[i+10], 9 ,  38016083);
        c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);
        b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);
        a = md5_gg(a, b, c, d, x[i+ 9], 5 ,  568446438);
        d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);
        c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);
        b = md5_gg(b, c, d, a, x[i+ 8], 20,  1163531501);
        a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);
        d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);
        c = md5_gg(c, d, a, b, x[i+ 7], 14,  1735328473);
        b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);
        a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);
        d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);
        c = md5_hh(c, d, a, b, x[i+11], 16,  1839030562);
        b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);
        a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);
        d = md5_hh(d, a, b, c, x[i+ 4], 11,  1272893353);
        c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);
        b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);
        a = md5_hh(a, b, c, d, x[i+13], 4 ,  681279174);
        d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);
        c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);
        b = md5_hh(b, c, d, a, x[i+ 6], 23,  76029189);
        a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);
        d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);
        c = md5_hh(c, d, a, b, x[i+15], 16,  530742520);
        b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);
        a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);
        d = md5_ii(d, a, b, c, x[i+ 7], 10,  1126891415);
        c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);
        b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);
        a = md5_ii(a, b, c, d, x[i+12], 6 ,  1700485571);
        d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);
        c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);
        b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);
        a = md5_ii(a, b, c, d, x[i+ 8], 6 ,  1873313359);
        d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);
        c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);
        b = md5_ii(b, c, d, a, x[i+13], 21,  1309151649);
        a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);
        d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);
        c = md5_ii(c, d, a, b, x[i+ 2], 15,  718787259);
        b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);
        a = safe_add(a, olda);
        b = safe_add(b, oldb);
        c = safe_add(c, oldc);
        d = safe_add(d, oldd);
      }
      return Array(a, b, c, d);
    }
    
    function md5_cmn(q, a, b, x, s, t){
      return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s),b);
    }
    function md5_ff(a, b, c, d, x, s, t){
      return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);
    }
    function md5_gg(a, b, c, d, x, s, t){
      return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);
    }
    function md5_hh(a, b, c, d, x, s, t){
      return md5_cmn(b ^ c ^ d, a, b, x, s, t);
    }
    function md5_ii(a, b, c, d, x, s, t){
      return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);
    }
    
    function core_hmac_md5(key, data) {
      var bkey = str2binl(key);
      if(bkey.length > 16) bkey = core_md5(bkey, key.length * chrsz);
      var ipad = Array(16), opad = Array(16);
      for(var i = 0; i < 16; i++) 
      {
        ipad[i] = bkey[i] ^ 0x36363636;
        opad[i] = bkey[i] ^ 0x5C5C5C5C;
      }
      var hash = core_md5(ipad.concat(str2binl(data)), 512 + data.length * chrsz);
      return core_md5(opad.concat(hash), 512 + 128);
    }
    
    function safe_add(x, y) {
      var lsw = (x & 0xFFFF) + (y & 0xFFFF);
      var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
      return (msw << 16) | (lsw & 0xFFFF);
    }
    
    function bit_rol(num, cnt) {
      return (num << cnt) | (num >>> (32 - cnt));
    }
    
    function str2binl(str) {
      var bin = Array();
      var mask = (1 << chrsz) - 1;
      for(var i = 0; i < str.length * chrsz; i += chrsz)
        bin[i>>5] |= (str.charCodeAt(i / chrsz) & mask) << (i%32);
      return bin;
    }
    
    function binl2hex(binarray) {
      var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
      var str = "";
      for(var i = 0; i < binarray.length * 4; i++)
      {
        str += hex_tab.charAt((binarray[i>>2] >> ((i%4)*8+4)) & 0xF) +
               hex_tab.charAt((binarray[i>>2] >> ((i%4)*8  )) & 0xF);
      }
      return str;
    }
    
    function binl2b64(binarray) {
      var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
      var str = "";
      for(var i = 0; i < binarray.length * 4; i += 3){
        var triplet = (((binarray[i   >> 2] >> 8 * ( i   %4)) & 0xFF) << 16)
                    | (((binarray[i+1 >> 2] >> 8 * ((i+1)%4)) & 0xFF) << 8 )
                    |  ((binarray[i+2 >> 2] >> 8 * ((i+2)%4)) & 0xFF);
        for(var j = 0; j < 4; j++)
        {
          if(i * 8 + j * 6 > binarray.length * 32) str += b64pad;
          else str += tab.charAt((triplet >> 6*(3-j)) & 0x3F);
        }
      }
      return str;
    }
    
    export const hex_md5 = function (s) { return binl2hex(core_md5(str2binl(s), s.length * chrsz));}
    export const b64_md5 = function (s){ return binl2b64(core_md5(str2binl(s), s.length * chrsz));}
    export const hex_hmac_md5 = function (key, data) { return binl2hex(core_hmac_md5(key, data)); }
    export const b64_hmac_md5 = function (key, data) { return binl2b64(core_hmac_md5(key, data)); }
    export const calcMD5 = function (s){ return binl2hex(core_md5(str2binl(s), s.length * chrsz));}
    

       在vue页面引入

    <script>
    import { hex_md5 } from '@/utils/md5.js' // 引入js文件
    export defult {
    ...
    }

      然后可以正常使用了。举个例子,结果不准确哈

    const md5 = hex_md5('0000000014'+'dewfqf'+'1648326598235')
    console.log(md5)      // 10adc3949ba59abbe56e057f20f883e

    更多相关内容
  • MD5.js js加密

    2017-10-26 11:19:24
    MD5.js 共有6中加密方法:hex_md5(s), b64_md5(s) ,str_md5(s) ,hex_hmac_md5(key, data), b64_hmac_md5(key, data) ,str_hmac_md5(key, data).根据需求选择. js加密的好处: 1,用js对私密信息加密可避免在网络中...
  • 真正MD5碰撞工具,压缩包里有2个软件: 1,fastcoll_v1.0.0.5 可以将原文件生成出2个新MD5值相同的文件。 2,文件MD5修改器正式版 可以将原文件,通过碰撞生成指定MD5值的新文件。(不要做坏事哦)
  • MD5加密jar包及案例

    2016-07-16 11:59:25
    MD5加密jar包及案例,其中含有两个MD5加密jar包,使用哪个都可以,及本人自己写的一个MD5算法工具类,也可以进行加密,三者选其一即可。附有案例
  • MD5的加密解密c#代码

    热门讨论 2014-08-19 15:21:34
    MD5加密解密工具,就我所知,MD5的目标是生成摘要。严格来说不是一种加密算法。 不管多长的信息都能生成固定长度的MD5编码的话,必然会有信息丢失。那么光有MD5编码的话是绝对不可能还原信息的。 那网上那些MD5解密...
  • MD5

    万次阅读 2017-12-13 10:35:53
    一、MD5介绍 MD5MD5消息摘要算法的简称(英语:MD5 Message-Digest Algorithm),是一种广泛使用的密码散列函数,可以产生出一个128位(16字节)的散列值(即哈希值),用于确保信息传输的完整性。MD5由罗纳德·...

    一、MD5介绍

    MD5是MD5消息摘要算法的简称(英语:MD5 Message-Digest Algorithm),是一种广泛使用的密码散列函数,可以产生出一个128位(16字节)的散列值(即哈希值),用于确保信息传输的完整性。MD5由罗纳德·李维斯特设计,于1992年公开,用以取代MD4算法。这套算法的程序在RFC 1321 中被加以规范。
    将数据(如一段文字)运算变为另一固定长度值,是散列算法的基础原理。
    MD5已经被证实可以被碰撞破解。对于需要高度安全性的数据,专家一般建议改用其他算法,如SHA-2。

    CMD5上可以根据MD5密文查询出对应明文。

    二、C++生成MD5

    libmd5是计算md5值的C++开源库。这里对libmd5进行二次封装,方便调用,支持生成字符串、文件的MD5值。调用GetStringMd5生成字符串MD5;调用GetFileMd5生成文件MD5值,文件大小不受限制,但是文件越大,生成md5的耗时就越长。

    Md5Maker.h

    #ifndef __MD5_MAKER_34DFDR7_H__
    #define __MD5_MAKER_34DFDR7_H__
    
    
    #include <string>
    
    namespace cpp4j
    {
        namespace libmd5
        {
            #define UWORD32 unsigned int
            #define md5byte unsigned char
    
            struct MD5Context {
                UWORD32 buf[4];
                UWORD32 bytes[2];
                UWORD32 in[16];
            };
    
            void MD5Init(struct MD5Context *context);
            void MD5Update(struct MD5Context *context, md5byte const *buf, unsigned len);
            void MD5Final(unsigned char digest[16], struct MD5Context *context);
            void MD5Buffer (const unsigned char *buf,unsigned int len,unsigned char sig[16]);
            void MD5SigToString(unsigned char sig[16],char *str,int len);
        }
    
        std::string GetStringMd5(const std::string &str);
        std::string GetStringMd5(const void *pData, unsigned int iDataSize);
        std::string GetFileMd5(const std::string &strFilePath);
    }
    
    #endif

    Md5Maker.cpp

    #include "Md5Maker.h"
    
    namespace cpp4j
    {
        namespace libmd5
        {
            /*
            * This code implements the MD5 message-digest algorithm.
            * The algorithm is due to Ron Rivest.  This code was
            * written by Colin Plumb in 1993, no copyright is claimed.
            * This code is in the public domain; do with it what you wish.
            *
            * Equivalent code is available from RSA Data Security, Inc.
            * This code has been tested against that, and is equivalent,
            * except that you don't need to include two pages of legalese
            * with every copy.
            *
            * To compute the message digest of a chunk of bytes, declare an
            * MD5Context structure, pass it to MD5Init, call MD5Update as
            * needed on buffers full of bytes, and then call MD5Final, which
            * will fill a supplied 16-byte array with the digest.
            *
            * Changed so as no longer to depend on Colin Plumb's `usual.h' header
            * definitions; now uses stuff from dpkg's config.h.
            *  - Ian Jackson <ian@chiark.greenend.org.uk>.
            * Still in the public domain.
            */
    
    #define HEX_STRING      "0123456789abcdef"      /* to convert to hex */
    
            int g_bigEndian = 0;
            int g_endianessDetected = 0;
    
            void detectEndianess()
            {
                int nl = 0x12345678;
                short ns = 0x1234;
    
                unsigned char *p = (unsigned char *)(&nl);
                unsigned char *sp = (unsigned char *)(&ns);
    
                if (g_endianessDetected) return;
    
                if ( p[0] == 0x12 && p[1] == 0x34 && p[2] == 0x56 && p[3] == 0x78 )
                {
                    g_bigEndian = 1;
                }
                else if ( p[0] == 0x78 && p[1] == 0x56 && p[2] == 0x34 && p[3] == 0x12 )
                {
                    g_bigEndian = 0;
                }
                else
                {
                    g_bigEndian = *sp != 0x12;
                }
    
                g_endianessDetected = 1;
            }
    
            void byteSwap(UWORD32 *buf, unsigned words)
            {
                md5byte *p;
    
                if (!g_bigEndian) return;
    
                p = (md5byte *)buf;
    
                do
                {
                    *buf++ = (UWORD32)((unsigned)p[3] << 8 | p[2]) << 16 |
                             ((unsigned)p[1] << 8 | p[0]);
                    p += 4;
                }
                while (--words);
            }
    
    #ifndef ASM_MD5
    
            /* The four core functions - F1 is optimized somewhat */
    
            /* #define F1(x, y, z) (x & y | ~x & z) */
    #define F1(x, y, z) (z ^ (x & (y ^ z)))
    #define F2(x, y, z) F1(z, x, y)
    #define F3(x, y, z) (x ^ y ^ z)
    #define F4(x, y, z) (y ^ (x | ~z))
    
            /* This is the central step in the MD5 algorithm. */
    #define MD5STEP(f,w,x,y,z,in,s) \
        (w += f(x,y,z) + in, w = (w<<s | w>>(32-s)) + x)
    
            /*
             * The core of the MD5 algorithm, this alters an existing MD5 hash to
             * reflect the addition of 16 longwords of new data.  MD5Update blocks
             * the data and converts bytes into longwords for this routine.
             */
            void MD5Transform(UWORD32 buf[4], UWORD32 const in[16])
            {
                register UWORD32 a, b, c, d;
    
                a = buf[0];
                b = buf[1];
                c = buf[2];
                d = buf[3];
    
                MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
                MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
                MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
                MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
                MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
                MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
                MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
                MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
                MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
                MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
                MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
                MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
                MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
                MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
                MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
                MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
    
                MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
                MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
                MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
                MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
                MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
                MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
                MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
                MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
                MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
                MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
                MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
                MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
                MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
                MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
                MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
                MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
    
                MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
                MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
                MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
                MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
                MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
                MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
                MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
                MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
                MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
                MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
                MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
                MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
                MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
                MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
                MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
                MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
    
                MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
                MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
                MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
                MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
                MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
                MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
                MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
                MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
                MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
                MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
                MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
                MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
                MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
                MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
                MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
                MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
    
                buf[0] += a;
                buf[1] += b;
                buf[2] += c;
                buf[3] += d;
            }
    
    #endif
    
            /*
             * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
             * initialization constants.
             */
            void MD5Init(struct MD5Context *ctx)
            {
                detectEndianess();
    
                ctx->buf[0] = 0x67452301;
                ctx->buf[1] = 0xefcdab89;
                ctx->buf[2] = 0x98badcfe;
                ctx->buf[3] = 0x10325476;
    
                ctx->bytes[0] = 0;
                ctx->bytes[1] = 0;
            }
    
            /*
             * Update context to reflect the concatenation of another buffer full
             * of bytes.
             */
            void MD5Update(struct MD5Context *ctx, md5byte const *buf, unsigned len)
            {
                UWORD32 t;
    
                /* Update byte count */
    
                t = ctx->bytes[0];
    
                if ((ctx->bytes[0] = t + len) < t)
                    ctx->bytes[1]++;    /* Carry from low to high */
    
                t = 64 - (t & 0x3f);    /* Space available in ctx->in (at least 1) */
    
                if (t > len)
                {
                    memcpy((md5byte *)ctx->in + 64 - t, buf, len);
                    return;
                }
    
                /* First chunk is an odd size */
                memcpy((md5byte *)ctx->in + 64 - t, buf, t);
                byteSwap(ctx->in, 16);
                MD5Transform(ctx->buf, ctx->in);
                buf += t;
                len -= t;
    
                /* Process data in 64-byte chunks */
                while (len >= 64)
                {
                    memcpy(ctx->in, buf, 64);
                    byteSwap(ctx->in, 16);
                    MD5Transform(ctx->buf, ctx->in);
                    buf += 64;
                    len -= 64;
                }
    
                /* Handle any remaining bytes of data. */
                memcpy(ctx->in, buf, len);
            }
    
            /*
             * Final wrapup - pad to 64-byte boundary with the bit pattern
             * 1 0* (64-bit count of bits processed, MSB-first)
             */
            void MD5Final(md5byte digest[16], struct MD5Context *ctx)
            {
                int count = ctx->bytes[0] & 0x3f;   /* Number of bytes in ctx->in */
                md5byte *p = (md5byte *)ctx->in + count;
    
                /* Set the first char of padding to 0x80.  There is always room. */
                *p++ = 0x80;
    
                /* Bytes of padding needed to make 56 bytes (-8..55) */
                count = 56 - 1 - count;
    
                if (count < 0)      /* Padding forces an extra block */
                {
                    memset(p, 0, count + 8);
                    byteSwap(ctx->in, 16);
                    MD5Transform(ctx->buf, ctx->in);
                    p = (md5byte *)ctx->in;
                    count = 56;
                }
    
                memset(p, 0, count);
                byteSwap(ctx->in, 14);
    
                /* Append length in bits and transform */
                ctx->in[14] = ctx->bytes[0] << 3;
                ctx->in[15] = ctx->bytes[1] << 3 | ctx->bytes[0] >> 29;
                MD5Transform(ctx->buf, ctx->in);
    
                byteSwap(ctx->buf, 4);
                memcpy(digest, ctx->buf, 16);
                memset(ctx, 0, sizeof(*ctx));   /* In case it's sensitive */
            }
    
            void MD5Buffer (const unsigned char *buf, unsigned int len, unsigned char sig[16])
            {
                struct MD5Context md5;
                MD5Init(&md5);
                MD5Update(&md5, buf, len);
                MD5Final(sig, &md5);
            }
    
            void MD5SigToString(unsigned char signature[16], char *str, int len)
            {
                unsigned char *sig_p;
                char          *str_p, *max_p;
                unsigned int  high, low;
    
                str_p = str;
                max_p = str + len;
    
                for (sig_p = (unsigned char *)signature;
                        sig_p < (unsigned char *)signature + 16;
                        sig_p++)
                {
                    high = *sig_p / 16;
                    low = *sig_p % 16;
    
                    /* account for 2 chars */
                    if (str_p + 1 >= max_p)
                    {
                        break;
                    }
    
                    *str_p++ = HEX_STRING[high];
                    *str_p++ = HEX_STRING[low];
                }
    
                /* account for 2 chars */
                if (str_p < max_p)
                {
                    *str_p++ = '\0';
                }
            }
        }
    
        std::string GetStringMd5(const std::string &str)
        {
            unsigned char md5Sig[16] = {0};
            char szMd5[33] = {0};
    
            libmd5::MD5Buffer((const unsigned char *)str.c_str(), str.length(), md5Sig);
            libmd5::MD5SigToString(md5Sig, szMd5, 33);
    
            return szMd5;
        }
    
        std::string GetStringMd5(const void *pData, unsigned int iDataSize)
        {
            unsigned char md5Sig[16] = {0};
            char szMd5[33] = {0};
    
            libmd5::MD5Buffer((const unsigned char *)pData, iDataSize, md5Sig);
            libmd5::MD5SigToString(md5Sig, szMd5, 33);
    
            return szMd5;
        }
    
        std::string GetFileMd5(const std::string &strFilePath)
        {
            FILE *f = NULL;
    
            if(fopen_s(&f, strFilePath.c_str(), "rb"))
                return "";
    
            unsigned char szMd5Sig[16] = {0};
            char szMd5[33] = {0};
            libmd5::MD5Context md5Context;
            libmd5::MD5Init(&md5Context);
    
            size_t dwReadBytes = 0;
            unsigned char szData[1024] = {0};
    
            while((dwReadBytes = fread(szData, 1, 1024, f)) > 0)
            {
                libmd5::MD5Update(&md5Context, szData, dwReadBytes);
            }
    
            fclose(f);
    
            libmd5::MD5Final(szMd5Sig, &md5Context);
            libmd5::MD5SigToString(szMd5Sig, szMd5, 33);
    
            return szMd5;
        }
    }

    参考:https://zh.wikipedia.org/wiki/MD5

    展开全文
  • 1、打开EXCEL,点[工具][加载宏][浏览],在硬盘中找到您下载的md5宏.xla,选择并勾选"md5宏.xla"; 2、比如A1为密码字串明文列,B1为md5加密列,则在点中B1后点[插入][函数][用户自定义],选择"Md5_string_Calc...
  • java实现md5 加密解密

    热门讨论 2013-08-20 09:58:44
    java实现md5 加密解密(在网络中MD5是著名的不可逆算法,但是如果知道MD5的加密的字符串 则可以通过自己的加密算法对明文进行加密,对加密后的密文与字符串匹配; 匹配成功,表示找到明文;但是此程序的时间耗费较高!仅...
  • android平台下基于java语言的md5加密及ndk环境下基于c语言的md5加密。
  • Linux 如何生成文件的MD5值(md5sum)?

    千次阅读 2022-04-29 10:25:08
    MD5算法一般用于检查文件完整性,md5sum是校验文件内容,与文件名是否相同无关。 测试:修改过文件生成的MD5的值都是不一样的,即使后期有改回去,MD5值也是不一样的。 二、生成多个文件的多个Md5值 命令:...

    目录

    一、生成某个文件的MD5值

    二、生成多个文件的多个Md5值

    三、补充相关知识点

    ·find命令

    ·xargs命令


    一、生成某个文件的MD5值

    MD5算法一般用于检查文件完整性,md5sum是校验文件内容,与文件名是否相同无关。

    测试:修改过文件生成的MD5的值都是不一样的,即使后期有改回去,MD5值也是不一样的。

     

    二、生成多个文件的多个Md5值

    命令:这里把要生成的文件都放在同一个目录下,这个命令结合了find命令和xargs命令来生成多个文件的MD5值

    find 目录 -type f -print0 | xargs -0 md5sum >> 2_md5.txt

     

    三、补充相关知识点

    ·find命令

    Linux find 命令

     

    ·xargs命令

    xargs(英文全拼: eXtended ARGuments)是给命令传递参数的一个过滤器,也是组合多个命令的一个工具。xargs 可以将管道或标准输入(stdin)数据转换成命令行参数,也能够从文件的输出中读取数据。xargs 也可以将单行或多行文本输入转换为其他格式,例如多行变单行,单行变多行。xargs 默认的命令是 echo,这意味着通过管道传递给 xargs 的输入将会包含换行和空白,不过通过 xargs 的处理,换行和空白将被空格取代

    之所以能用到这个命令,关键是由于很多命令不支持|管道来传递参数,而日常工作中有有这个必要,所以就有了 xargs 命令,例如:

    find /sbin -perm +700 |ls -l       #这个命令是错误的
    find /sbin -perm +700 |xargs ls -l   #这样才是正确的

    xargs 一般是和管道一起使用。

    命令格式:

    somecommand | xargs -item  command

    实例:

    ·xargs 结合 find 使用

    用 rm 删除太多的文件时候,可能得到一个错误信息:/bin/rm Argument list too long. 用 xargs 去避免这个问题:

    find . -type f -name "*.log" -print0 | xargs -0 rm -f

    xargs -0 将 \0 作为定界符。

    统计一个源代码目录中所有 php 文件的行数:

    find . -type f -name "*.php" -print0 | xargs -0 wc -l

    查找所有的 jpg 文件,并且压缩它们:

    find . -type f -name "*.jpg" -print | xargs tar -czvf images.tar.gz

    ·xargs 用作替换工具,读取输入数据重新格式化后输出。

    定义一个测试文件,内有多行文本数据:

    # cat test.txt
    
    a b c d e f g
    h i j k l m n
    o p q
    r s t
    u v w x y z

    多行输入单行输出:

    # cat test.txt | xargs
    a b c d e f g h i j k l m n o p q r s t u v w x y z

    -n 选项多行输出:

    # cat test.txt | xargs -n3
    
    a b c
    d e f
    g h i
    j k l
    m n o
    p q r
    s t u
    v w x
    y z

    -d 选项可以自定义一个定界符:

    # echo "nameXnameXnameXname" | xargs -dX
    
    name name name name

    结合 -n 选项使用:

    # echo "nameXnameXnameXname" | xargs -dX -n2
    
    name name
    name name
    # cat arg.txt
    
    aaa
    bbb
    ccc

    ·xargs 的一个选项 -I,使用 -I 指定一个替换字符串 {},这个字符串在 xargs 扩展时会被替换掉,当 -I 与 xargs 结合使用,每一个参数命令都会被执行一次

    复制所有图片文件到 /data/images 目录下:

    ls *.jpg | xargs -n1 -I {} cp {} /data/images

    xargs后面的参数说明:

    -d delim

    分隔符,默认的xargs分隔符是回车,argument的分隔符是空格,这里修改的是xargs的分隔符
    -n num后面加次数,表示命令在执行的时候一次用的argument的个数,默认是用所有的
    -i ,或-I,这得看linux支持了,将xargs的每项名称,一般是一行一行赋值给 {},可以用 {} 代替
    -l num或-L num 从标准输入一次读取 num 行送给 command 命令
    -t 表示先打印命令,然后再执行
    -p 当每次执行一个argument的时候询问一次用户

    其他:

    Linux echo命令

     

    展开全文
  • md5sum

    千次阅读 2022-04-28 10:34:03
    NAME md5sum - 计算检验MD5效验码 总览 (SYNOPSIS) ../src/md5sum [OPTION] [FILE]... ../src/md5sum [OPTION] --check [FILE] 描述 (DESCRIPTION) 显示 或 检验 MD5 效验码. 如果 没有 FILE 或者 FILE 是 - 时...

    1.md5sum命令的作用

    主要是用于验证网络文件传输的完整性,防止文件被篡改。主要是因为在网络环境不稳定的情况下,传输的文件很有可能会发生前后数据不一致的情况.

    2.md5sum命令的原理

    采用MD5报文摘要算法(128位) 计算和检查文件的校验和。只会逐位对文件的内容进行校验,与文件名无关。当文件内容相同时,md5值也是相同的。md5值是一个128位的二进制数据,转换成16进制则是32位的进制值。

    注意: md5校验,有很小的概率不同的文件生成的md5可能相同,但大概率是可以大概检测文件的完整性.

    3.手册 

    
    NAME  md5sum - 计算检验MD5效验码
    
    总览 (SYNOPSIS)
           ../src/md5sum [OPTION] [FILE]...
           ../src/md5sum [OPTION] --check [FILE]
    
    描述 (DESCRIPTION)
           显示或检验MD5效验码. 如果没有FILE或者FILE是-时,就从标准输入读入.
           -b, --binary  以 二进制 模式 读入 文件 (DOS/Windows 下 默认)
           -c, --check   对 给定 的 文件 检验 MD5 效验码
           -t, --text    以 文本 模式 读入 文件 (默认)
    
     下面的两个选项只在检验效验码时用:
           --status  不显示 任何 输出, 用 返回码 表示 成功 与否
           -w, --warn 对于错误的MD5效验码行的格式发出警告
           --help     显示这个帮助然后退出
           --version  显示版本信息然后退出
    

    展开全文
  • Oracle的MD5函数介绍

    千次阅读 2020-12-29 07:50:00
    老婆问了个问题,Oracle中可以生成MD5值?快速解决领导问题是第一位的,搜了一下,Oracle 11g,创建自定义函数,可以得到对应的MD5,SQL> CREATE OR RE...
  • Linux下使用md5sum计算和检验MD5

    千次阅读 2021-06-02 18:27:18
    1、md5介绍在网络传输、设备之间转存、复制大文件等时,可能会出现传输前后数据不一致的情况. 这种情况在网络这种相对更不稳定的环境中,容易出现. 那么校验文件的完整性,也是势在必行的。2、md5sum命令md5sum命令...
  • MD5密文破解实验

    千次阅读 2021-10-24 20:12:28
    2、使用MD5Crack工具进行MD5解密 3、使用网络资源对密文进行在线破解 4、认真阅读并掌握本实验相关的知识点 5、上机实现实验所提到的工具和操作,得到实验结果,并填写实验报告 预备知识 MD5介绍 1991年,...
  • MD5和RSA加密算法Java完成实现

    千次下载 热门讨论 2014-05-21 22:29:18
    MD5和RSA加密算法Java完成实现,及实现RSA需要用的jar包。参见博文 http://blog.csdn.net/yanzi1225627/article/details/26508035
  • MD5加密算法(C语言实现,已编译,亲试可用~)

    千次阅读 热门讨论 2021-03-02 09:26:59
    C语言实现MD5加密算法 本文有部分内容参考引用百度百科-MD5MD5 MD5信息摘要算法(英语:MD5 Message-Digest Algorithm),一种被广泛使用的密码散列函数,可以产生出一个128位(16字节)的散列值(hash value...
  • C语言实现md5加密

    千次阅读 2019-09-05 11:40:42
    网上找到的实现md5函数代码,包括一个头文件md5.h和一个源文件md5.c,用下面的测试代码test.c测试通过,各文件依次如下: 1、md5.h #ifndef MD5_H #define MD5_H typedef struct { unsigned int count[2]; ...
  • 怎么看md5

    千次阅读 2021-05-13 12:09:25
    linux下怎么看文件的md5值Linux下查询文件的MD5值:md5sum xxx.iso.md5MD5算法常常被用来验证网络文件传输的完整性,防止文件被人篡改。MD5全称是报文摘要算法(Message-Digest Algorithm 5),此算法对任意长度的信息...
  • MD5 使用与jar包 java

    热门讨论 2012-09-03 11:33:23
    此为MD5的加密所需要的jar文件 MD5加密只需要此jar包 和如下代码将可获得加密结果,希望大家用的开心 //导入此import import cryptix.jce.provider.MD5; //MD5加密签名 String password ="1234567"; MD5 md5 = ...
  • MD5加密详解

    千次阅读 2021-12-27 19:58:06
    MD5加密详解 加密过程: 密码:123456 (明文形式)----->加密后 49ba59abbe56e057 1.密码在请求提交后到达控制器 2.到达控制后通过加密规则,转换成密文 3.在经过DAO查询与数据库中已经存在的密文密码比对是否...
  • 使用MD5对前后端进行加密

    万次阅读 2021-11-23 21:10:46
    但是从用户数据的安全性来讲,前后端是都...当然,加密算法有很多,这里我就简单介绍一下使用MD5进行加密吧。 前端 1、在public下面新建一个MD5.js工具类 MD5 的内容: var KEY = "!@#QWERT"; /* * Configurable varia
  • Flutter 项目实战 网络请求MD5+时间戳+验证签名 十一

    千次阅读 多人点赞 2022-01-12 13:40:12
    密钥可以是任意字符串 , 为了增加破解难度 ,客户端和服务端协商的密钥字符串长度尽量要长。密钥分别在客户端和服务端保存了...通过遍历集合拼接好的字符串末尾拼接协商的密钥 , 将这个拼接好的字符串通过Md5算法加密。
  • 使用spark-md5获取文件md5

    千次阅读 2021-12-10 19:46:48
    * 分片获取md5值 * @param {*} file 文件对象 * @param {*} chunkSize 分片大小 * @param {*} processCallback 进度修改回调 * @returns */ function md5WithChunk(file, chunkSize, processCallback = ...
  • MD5加密

    万次阅读 2022-03-26 16:11:45
    MD5加密 MD5算法为计算机安全领域广泛使用的一种散列函数,用于提供消息的完整性,是计算机广泛使用的哈希算法之一 MD5的固定长度为128比特,16字节,通常用他的16进制字面值输出他,是一个长度为32位的字符串。 MD5...
  • js MD5的6种实现方式

    万次阅读 2020-06-01 22:25:20
    js MD5的6种实现方式js代码使用 js代码 /* * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message * Digest Algorithm, as defined in RFC 1321. * Version 2.1 Copyright (C) Paul ...
  • java md5 jar

    热门讨论 2010-12-30 15:56:14
    java md5 jar 有代码如下: /** * md5 加密 * @param str * @return */ public static String md5Encode(String str) { StringBuffer buf = new StringBuffer(); try { ...
  • Linux命令之MD5校验md5sum

    千次阅读 2022-05-24 14:31:54
    `md5sum` 用于计算和校验文件的MD5值。
  • MD5加密概述,原理及实现

    万次阅读 多人点赞 2019-05-21 20:53:01
    MD5概述: MD5消息摘要算法,属Hash算法一类。MD5算法对输入任意长度的消息进行运行,产生一个128位的消息摘要(32位的数字字母混合码)。 MD5主要特点: 不可逆,相同数据的MD5值肯定一样,不同数据的MD5值不一样 ...
  • 二、MD5 加密原理和特性 三、MD5 加密算法的 Python 实现 四、MD5 撞库解密的简单 Python 实现与演示流程 五、MD5算法的改进——加入字符串 六、关于密码的查看和建议 附录: 1、其他破解方法对比 2、MD5在线加密...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,759,338
精华内容 1,103,735
关键字:

md5