MD5 算法实现（c++）

最新推荐文章于 2018-12-03 00:36:00 发布
最新推荐文章于 2018-12-03 00:36:00 发布
阅读量153 收藏
点赞数
分类专栏： C++ 文章标签： c/c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hulefei29/article/details/84588281
版权

用c++实现了md5算法。包含 md5.h 和md5.cpp 两个文件。

主要参考百度百科 “MD5” 原理的描述：http://baike.baidu.cn/view/7636.htm，代码中变量命名也是参考其中的公式，程序的使用说明在md5.h 文件的末尾注释中。

测试结果和百度百科测试例子一致。

实现过程中需要注意事项：最后把四个变量A B C D 链接成结果时 ，注意变量高低位的先后顺序，具体参考 LinkResult（）方法。

md5.h

#include <iostream>
#include <string>
using namespace std;

class MD5
{
    public:
        typedef unsigned char uchar8; //make sure it is 8bit
        typedef char char8; //make sure it is 8bit
        MD5();
        
        void init();

        void UpdateMd5(const uchar8 input[], const int length);      
        void UpdateMd5(const char8 input[], const int length);     
        
        void Finalize();
        
        void ComputMd5(const uchar8 input[], const int length); 
        void ComputMd5(const char8 input[], const int length); 
        
        string GetMd5();
        
        void printMd5();
        
        
    private:
        typedef unsigned int uint32;       //make sure it is 32 bit;
        typedef unsigned long long uint64; //make sure it is 64 bit;
        uint32 A, B, C, D;
        const static int blockLen_ = 64;    // 512/8                                  
        //the remain after last updata (because md5 may be computed segment by segment)
        uchar8 remain_[blockLen_];                    
        int remainNum_ ;         // the number of remain_,  < 64 
        uint64 totalInputBits_;
        uchar8 md5Result_[16];   //bit style md5 result,totally 128 bit
        char md5Result_hex_[33]; //hexadecimal style result; md5Result_hex_[32]='\0'
        bool isDone_;            // indicate the comput is finished;
                   
        inline uint32 RotateLeft(const uint32 x, int n);
        inline uint32 F(const uint32 x, const uint32 y, const uint32 z);
        inline uint32 G(const uint32 x, const uint32 y, const uint32 z);
        inline uint32 H(const uint32 x, const uint32 y, const uint32 z);
        inline uint32 I(const uint32 x, const uint32 y, const uint32 z);
        inline void FF(uint32 &a, const uint32 b, const uint32 c, const uint32 d,
                       const uint32 Mj, const int s, const uint32 ti);
        inline void GG(uint32 &a, const uint32 b, const uint32 c, const uint32 d,
                       const uint32 Mj, const int s, const uint32 ti);
        inline void HH(uint32 &a, const uint32 b, const uint32 c, const uint32 d,
                       const uint32 Mj, const int s, const uint32 ti);
        inline void II(uint32 &a, const uint32 b, const uint32 c, const uint32 d,
                       const uint32 Mj, const int s, const uint32 ti);
                       

        void UcharToUint(uint32 output[], const uchar8 input[], const unsigned int transLength);
        
        void FourRound(const uchar8 block[]);    

        void LinkResult();
                    
};

/* user guide
   you can comput the md5 by using the funtion ComputMd5
   eg:
       MD5 m;
       MD5::char8 str[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
       m.ComputMd5(str,sizeof(str) - 1);   
       m.printMd5();

    if you want to comput segment by segment,you can do as follow, and init() is suggested 
    the begging,and Finalize() must call in the end:
        
        MD5 M;
        m.init();
        MD5::uchar8 str1[] = "ABCDEFGHIJKLMN";
        MD5::uchar8 str2[] = "OPQRSTUVWXYZabcdefghijk";
        MD5::uchar8 str3[] = "lmnopqrstuvwxyz";
        m.UpdateMd5(str1,sizeof(str1) - 1);
        m.UpdateMd5(str2,sizeof(str2) - 1);
        m.UpdateMd5(str3,sizeof(str3) - 1);
        m.Finalize();
        m.printMd5();

    if you want to comput the md5 of a file, you can use the interface of this program.
*/

#endif

 

md5.cpp

#include"md5.h"

#include<iostream>
using namespace std;

const int S[4][4] = {7, 12, 17, 22,
                     5, 9, 14, 20,
                     4, 11, 16, 23,
                     6, 10, 15, 21};
void MD5::init()
{
    A = 0x67452301;
    B = 0xefcdab89;
    C = 0x98badcfe;
    D = 0x10325476;
    remainNum_ = 0;
    remain_[0] = '\0';
    md5Result_hex_[0] = '\0';
    md5Result_[0] = '\0';
    totalInputBits_ = 0;
    isDone_ = false;
}

MD5::MD5()
{
    init();
}

inline MD5::uint32 MD5::RotateLeft(const uint32 x, int n)
{
    return (x << n) | (x >> (32-n));        
    // if x is signed, use: (x << n) | ((x & 0xFFFFFFFF) >> (32-n))
}
inline MD5::uint32 MD5::F(const uint32 x, const uint32 y, const uint32 z)
{
    return (x & y) | ((~x) & z);
}
inline MD5::uint32 MD5::G(const uint32 x, const uint32 y, const uint32 z)
{
    return (x & z) | (y & (~z));
}
inline MD5::uint32 MD5::H(const uint32 x, const uint32 y, const uint32 z)
{
    return x ^ y ^ z;
}
inline MD5::uint32 MD5::I(const uint32 x, const uint32 y, const uint32 z)
{
    return y ^ (x | (~z));
}

inline void MD5::FF(uint32 &a, const uint32 b, const uint32 c, const uint32 d,
                    const uint32 Mj, const int s, const uint32 ti)
{
    a = b + RotateLeft(a + F(b, c, d) + Mj + ti, s);
}      
inline void MD5::GG(uint32 &a, const uint32 b, const uint32 c, const uint32 d,
                    const uint32 Mj, const int s, const uint32 ti)
{
    a = b + RotateLeft(a + G(b, c, d) + Mj + ti, s);
}                   
inline void MD5::HH(uint32 &a, const uint32 b, const uint32 c, const uint32 d,
                    const uint32 Mj, const int s, const uint32 ti)
{
    a = b + RotateLeft(a + H(b, c, d) + Mj + ti, s);
}                    
inline void MD5::II(uint32 &a, const uint32 b, const uint32 c, const uint32 d,
                    const uint32 Mj, const int s, const uint32 ti)
{
    a = b + RotateLeft(a + I(b, c, d) + Mj + ti, s);
}          

// link A B C D to result(bit style result and hexadecimal style result)
void MD5::LinkResult()
{
    //bit style result
    for(int i = 0; i < 4; i++)  //link A: low to high
    {
        md5Result_[i] = (A >> 8*i) & 0xff;
    }
    for(int i = 4; i<8; i++)   //link B: low to high
    {
        md5Result_[i] = (B >> 8*(i - 4)) & 0xff;
    }
    for(int i = 8; i<12; i++)  //link C: low to high
    {
        md5Result_[i] = (C >> 8*(i - 8)) & 0xff;
    }
    for(int i = 12; i<16; i++)  //link D: low to high
    {
        md5Result_[i] = (D >> 8*(i - 12)) & 0xff;
    }

    //change to hexadecimal style result
    // note: it is not the same as simply link hex(A) hex(B) hex(C) hex(D)
    for(int i = 0; i < 16; i++)
        sprintf(& md5Result_hex_[i*2], "%02x", md5Result_[i]);
    md5Result_hex_[32] = '\0';

}

//print the md5 by hex
void MD5::printMd5()
{
    if(!isDone_)
    {
        cout<< "Error: computation is not finished" <<endl;
        
    }
    else
        cout<< "MD5 Value: " << md5Result_hex_ <<endl;
}

//get the md5 value of hex style 
string MD5::GetMd5()
{
    if(!isDone_)
    {
        cout<< "Error: computation is not finished" <<endl;
        exit(0);
    }
    string a((const char *)md5Result_hex_);
    return a;
}

void MD5::UcharToUint(uint32 output[], const uchar8 input[], const unsigned int transLength)         
{
    for(int i = 0, j = 0; j < transLength; i++, j += 4)
    {
        output[i] = ((uint32)input[j]) | (((uint32)input[j+1]) << 8) |
                (((uint32)input[j+2]) << 16) | (((uint32)input[j+3]) << 24);
    }
}

// four round on a block of 512 bits;
void MD5::FourRound(const uchar8 block[])
{
    uint32 a = A, b = B, c = C, d = D;
    uint32 M[16];
    UcharToUint(M, block, blockLen_); //blockLen_ is a const int =64;
    
    //round 1
    FF (a, b, c, d, M[ 0], S[0][0], 0xd76aa478); 
    FF (d, a, b, c, M[ 1], S[0][1], 0xe8c7b756); 
    FF (c, d, a, b, M[ 2], S[0][2], 0x242070db); 
    FF (b, c, d, a, M[ 3], S[0][3], 0xc1bdceee); 
    FF (a, b, c, d, M[ 4], S[0][0], 0xf57c0faf); 
    FF (d, a, b, c, M[ 5], S[0][1], 0x4787c62a); 
    FF (c, d, a, b, M[ 6], S[0][2], 0xa8304613);
    FF (b, c, d, a, M[ 7], S[0][3], 0xfd469501);
    FF (a, b, c, d, M[ 8], S[0][0], 0x698098d8); 
    FF (d, a, b, c, M[ 9], S[0][1], 0x8b44f7af);
    FF (c, d, a, b, M[10], S[0][2], 0xffff5bb1); 
    FF (b, c, d, a, M[11], S[0][3], 0x895cd7be); 
    FF (a, b, c, d, M[12], S[0][0], 0x6b901122);
    FF (d, a, b, c, M[13], S[0][1], 0xfd987193);
    FF (c, d, a, b, M[14], S[0][2], 0xa679438e);
    FF (b, c, d, a, M[15], S[0][3], 0x49b40821); 

    // round 2 
    GG (a, b, c, d, M[ 1], S[1][0], 0xf61e2562); 
    GG (d, a, b, c, M[ 6], S[1][1], 0xc040b340); 
    GG (c, d, a, b, M[11], S[1][2], 0x265e5a51); 
    GG (b, c, d, a, M[ 0], S[1][3], 0xe9b6c7aa);
    GG (a, b, c, d, M[ 5], S[1][0], 0xd62f105d); 
    GG (d, a, b, c, M[10], S[1][1],  0x2441453); 
    GG (c, d, a, b, M[15], S[1][2], 0xd8a1e681);
    GG (b, c, d, a, M[ 4], S[1][3], 0xe7d3fbc8); 
    GG (a, b, c, d, M[ 9], S[1][0], 0x21e1cde6);
    GG (d, a, b, c, M[14], S[1][1], 0xc33707d6);
    GG (c, d, a, b, M[ 3], S[1][2], 0xf4d50d87);
    GG (b, c, d, a, M[ 8], S[1][3], 0x455a14ed); 
    GG (a, b, c, d, M[13], S[1][0], 0xa9e3e905); 
    GG (d, a, b, c, M[ 2], S[1][1], 0xfcefa3f8); 
    GG (c, d, a, b, M[ 7], S[1][2], 0x676f02d9);
    GG (b, c, d, a, M[12], S[1][3], 0x8d2a4c8a);

    //round 3 
    HH (a, b, c, d, M[ 5], S[2][0], 0xfffa3942); 
    HH (d, a, b, c, M[ 8], S[2][1], 0x8771f681); 
    HH (c, d, a, b, M[11], S[2][2], 0x6d9d6122); 
    HH (b, c, d, a, M[14], S[2][3], 0xfde5380c);
    HH (a, b, c, d, M[ 1], S[2][0], 0xa4beea44); 
    HH (d, a, b, c, M[ 4], S[2][1], 0x4bdecfa9);
    HH (c, d, a, b, M[ 7], S[2][2], 0xf6bb4b60); 
    HH (b, c, d, a, M[10], S[2][3], 0xbebfbc70); 
    HH (a, b, c, d, M[13], S[2][0], 0x289b7ec6); 
    HH (d, a, b, c, M[ 0], S[2][1], 0xeaa127fa); 
    HH (c, d, a, b, M[ 3], S[2][2], 0xd4ef3085);
    HH (b, c, d, a, M[ 6], S[2][3],  0x4881d05); 
    HH (a, b, c, d, M[ 9], S[2][0], 0xd9d4d039); 
    HH (d, a, b, c, M[12], S[2][1], 0xe6db99e5); 
    HH (c, d, a, b, M[15], S[2][2], 0x1fa27cf8); 
    HH (b, c, d, a, M[ 2], S[2][3], 0xc4ac5665); 
  
    //round 4 
    II (a, b, c, d, M[ 0], S[3][0], 0xf4292244); 
    II (d, a, b, c, M[ 7], S[3][1], 0x432aff97); 
    II (c, d, a, b, M[14], S[3][2], 0xab9423a7); 
    II (b, c, d, a, M[ 5], S[3][3], 0xfc93a039);
    II (a, b, c, d, M[12], S[3][0], 0x655b59c3); 
    II (d, a, b, c, M[ 3], S[3][1], 0x8f0ccc92); 
    II (c, d, a, b, M[10], S[3][2], 0xffeff47d); 
    II (b, c, d, a, M[ 1], S[3][3], 0x85845dd1); 
    II (a, b, c, d, M[ 8], S[3][0], 0x6fa87e4f); 
    II (d, a, b, c, M[15], S[3][1], 0xfe2ce6e0); 
    II (c, d, a, b, M[ 6], S[3][2], 0xa3014314); 
    II (b, c, d, a, M[13], S[3][3], 0x4e0811a1); 
    II (a, b, c, d, M[ 4], S[3][0], 0xf7537e82); 
    II (d, a, b, c, M[11], S[3][1], 0xbd3af235); 
    II (c, d, a, b, M[ 2], S[3][2], 0x2ad7d2bb);
    II (b, c, d, a, M[ 9], S[3][3], 0xeb86d391); 
  
    A += a;
    B += b;
    C += c;
    D += d;
}

// update md5,must consider the remain_.
void MD5::UpdateMd5(const uchar8 input[], const int length)
{    
    isDone_ = false;
    totalInputBits_ += (length << 3);
    
    int start = blockLen_ - remainNum_; //blockLen_ = 64
    //copy a part of input to remain_ so it can form a block(size=64)
  
    if(start <= length)
    {
        // can form a block,then do FourRound to this block
            memcpy(&remain_[remainNum_], input, start) ;
            FourRound(remain_);

            int i;
            for(i = start; i <= length - blockLen_; i += blockLen_)
            {
                FourRound(&input[i]);
            }
            remainNum_ = length - i;  
            memcpy(remain_, &input[i], remainNum_);  
    }     
    else
    {
        // can not form a block, function return;
        memcpy(&remain_[remainNum_], input, length);
        remainNum_ += length;
    }    
    
}

void MD5::UpdateMd5(const char8 input[], const int length)
{
    UpdateMd5((const uchar8 *)input, length);
}

// padding with 100000... to remain_ and add the 64bit original size of input 
void MD5::Finalize()
{
    if(isDone_ == true)
        return;
        
    uchar8 padding[64] = {
    0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    };
 
    int temp = 56 - remainNum_;  //56 = 448/8
    if(temp > 0)
    {
        UpdateMd5(padding, temp);
        totalInputBits_ -= (temp << 3);
    }
    else if(temp < 0)
    {
        UpdateMd5(padding, 64 + temp);
        totalInputBits_ -= ((64 + temp) << 3);
    }
 
    // trans totalInputBits_ to uchar8 (64bits)
    uchar8 Bits[8];
    for(int i = 0; i < 8; i++)
    {
        Bits[i] = (totalInputBits_ >> 8*i) & 0xff;
    }
    
    UpdateMd5(Bits, 8); // add the number of  original input (the last 64bits)
    
    LinkResult();
    isDone_ = true;
}

// comput the md5 based on input, (just this one input)
void MD5::ComputMd5(const uchar8 input[], const int length)
{
    init();
    UpdateMd5(input, length);
    Finalize();
}

void MD5::ComputMd5(const char8 input[], const int length)
{
    ComputMd5((const uchar8 *)input, length);
}

 

hulefei29
关注
专栏目录
MD5算法C++实现
08-27
MD5算法的C++实现的代码，提供给需要的同学，主要的目的方便自己逆向工程的时候要用到，方便查找。
MD5算法的C++实现和调用程序
09-25
MD5 算法是用来进行数字签名和算法。能将任意长的字符串生产128位长的等长字符。
MD5算法——C++实现
weixin_30340617的博客
12-03 588
MD5算法原理 MD5消息摘要算法，属Hash算法一类。MD5算法对输入任意长度的消息进行运行，产生一个128位的消息摘要。 具体实现可参考博客 https://blog.csdn.net/sinat_27933301/article/details/79538169 和官方标准RFC1321 https://tools.ietf.org/html/...
MD5算法(C++实现)
老姜的专栏
02-02 8284
.h文件/****************************************************************************** *  Copyright (C) 2000 by Robert Hubley.                                      * *  All rights reserved.            
基于C++实现 MD5 算法的文件完整性校验程序【100010122】
最新发布
12-15
基于 MD5 算法的文件完整性校验程序，本实验使用 C++ 语言在 Linux 平台进行编程和运行。 ./md5 -h 查看帮助 ./md5 -t 打印程序的测试信息 ./md5 -c nankai.txt 计算出的被测文件的 MD5 摘要并打印 ./md5 -v nankai....
C/C++ MD5算法的实现代码
12-26
在逆向程序的时候，经常会碰到加密的算法的问题，前面分析UC的逆向工程师的面试题2的时候，发现使用了MD5的加密算法（MD5算法是自己实现的，不是使用的算法库函数）。尤其是在逆向分析网络协议的时候，一般的程序...
MD5 加密算法 C++实现源码
10-19
在C++中实现MD5加密算法，通常包括以下几个步骤： 1. **初始化MD5状态**: 创建一个128位的缓冲区，用于存储中间结果，初始化为一组固定的常量。 2. **处理输入数据**: 将输入的明文数据按照512位的块进行处理。...
C++实现MD5算法程序设计与实现.zip
07-06
资源包含文件：设计报告word+源码及可执行exe文件 ...MD5实现的基本过程为填充，分块，缓冲区初始化，循环压缩，得出结果。 详细介绍参考：https://blog.csdn.net/sheziqiong/article/details/125636590
md5算法的c++实现
10-12
看到一个不错的c++实现的md5算法 class MD5 { public: typedef unsigned int size_type; // must be 32bit MD5(); MD5(const std::string& text); void update(const unsigned char *buf, size_type length); void update(const char *buf, size_type length); MD5& finalize(); std::string hexdigest() const; friend std::ostream& operator<<(std::ostream&, MD5 md5); private: void init(); typedef unsigned char uint1; // 8bit typedef unsigned int uint4; // 32bit enum {blocksize = 64}; // VC6 won't eat a const static int here void transform(const uint1 block[blocksize]); static void decode(uint4 output[], const uint1 input[], size_type len); static void encode(uint1 output[], const uint4 input[], size_type len); bool finalized; uint1 buffer[blocksize]; // bytes that didn't fit in last 64 byte chunk uint4 count[2]; // 64bit counter for number of bits (lo, hi) uint4 state[4]; // digest so far uint1 digest[16]; // the result // low level logic operations static inline uint4 F(uint4 x, uint4 y, uint4 z); static inline uint4 G(uint4 x, uint4 y, uint4 z); static inline uint4 H(uint4 x, uint4 y, uint4 z); static inline uint4 I(uint4 x, uint4 y, uint4 z); static inline uint4 rotate_left(uint4 x, int n); static inline void FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac); static inline void GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac); static inline void HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac); static inline void II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac); }; std::string md5(const std::string &str);
C++ MD5算法的实现
01-14
C++ MD5算法的实现，在VC6.0下编译通过。
MD5算法c++程序设计实现
12-09
MD5算法是广泛 使用的 Hash 算法，用于确保信息传输的完整性和一致性。 MD5算法的c++程序设计和实现。
C++实现的MD5算法
09-10
用C++写的MD5,带工程文件,下载后就可以运行的
C++实现md5加密算法
04-08
md5 用c++实现md5算法. 开发平台 Ubuntu14.04 运行 sudo get-apt install g++ make ./md5_test md5简介 消息摘要算法第五版（英语：Message-Digest Algorithm 5，缩写为MD5），是当前计算机领域用于确保信息传输完整一致而广泛使用的散列算法之一（又译哈希算法、摘要算法等），主流编程语言普遍已有MD5的实现。将数据 （如一段文字）运算变为另一固定长度值，是散列算法的基础原理，MD5的前身有MD2、MD3和MD4。MD5由MD4、MD3、MD2改进而来，主要增强算法复杂度和不可逆性。目前，MD5算法因其普遍、稳定、快速的特点，仍广泛应用于普通 数据的错误检查领域。例如在一些BitTorrent下载中，软件将通过计算MD5检验下载到的文件片段的完整性。MD5已经广泛使用在为文件传输提供一定的可靠性方面。例如，服务器预先提供一个MD5校验和，用户下载完文件以后， 用MD5算法计算下载文件的MD5校验和，然后通过检查这两个校验和是否一致，就能判断下载的文件是否出错。MD5是输入不定长度信息，输出固定长度128-bits的算法。经过程序流程，生成四个32位数据，最后联合起来成为一个 128-bits散列。基本方式为，求余、取余、调整长度、与链接变量进行循环运算。得出结果。 md5算法描述 假设输入信息(input message)的长度为b(bit)，我们想要产生它的报文摘要，在此处b为任意的非负整数：b也可能为0，也不一定为8的整数倍，且可能是任意大的长度。设该信息的比特流表示如下： M[0] M[1] M[2] ... M[b-1] 计算此信息的报文摘要需要如下5步： 1.补位 信息计算前先要进行位补位，设补位后信息的长度为LEN(bit)，则LEN%512 = 448(bit)，即数据扩展至 K * 512 + 448(bit)。即K * 64+56(byte)，K为整数。补位操作始终要执行，即使补位前信息的长度对512求余的结果是448。具体补位操作：补一个1，然后补0至满足上述要求。总共最少要补1bit，最多补512bit。 2.尾部加上信息长度 将输入信息的原始长度b(bit)表示成一个64-bit的数字，把它添加到上一步的结果后面(在32位的机器上，这64位将用2个字来表示并且低位在前)。当遇到b大于2^64这种极少的情况时，b的高位被截去，仅使用b的低64位。经过上面两步，数据就被填补成长度为512(bit)的倍数。也就是说，此时的数据长度是16个字(32byte)的整数倍。此时的数据表示为： M[0 ... N-1] 其中的N是16的倍数。 3.初始化缓存区 用一个四个字的缓冲器(A，B，C，D)来计算报文摘要，A,B,C,D分别是32位的寄存器，初始化使用的是十六进制表示的数字，注意低字节在前： word A: 01 23 45 67 word B: 89 ab cd ef word C: fe dc ba 98 word D: 76 54 32 10 4.转换 首先定义4个辅助函数，每个函数的输入是三个32位的字，输出是一个32位的字： F(X,Y,Z) = XY v not(X) Z G(X,Y,Z) = XZ v Y not(Z) H(X,Y,Z) = X xor Y xor Z I(X,Y,Z) = Y xor (X v not(Z)) 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) Ⅱ（a,b,c,d,Mj,s,ti）表示 a = b + ((a + I(b,c,d) + Mj + ti) << s) 这四轮（64步）是： 第一轮 FF(a,b,c,d,M0,7,0xd76aa478） FF(d,a,b,c,M1,12,0xe8c7b756） FF(c,d,a,b,M2,17,0x242070db) FF(b,c,d,a,M3,22,0xc1bdceee) FF(a,b,c,d,M4,7,0xf57c0faf) FF(d,a,b,c,M5,12,0x4787c62a) FF(c,d,a,b,M6,17,0xa8304613） FF(b,c,d,a,M7,22,0xfd469501） FF(a,b,c,d,M8,7,0x698098d8） FF(d,a,b,c,M9,12,0x8b44f7af) FF(c,d,a,b,M10,17,0xffff5bb1） FF(b,c,d,a,M11,22,0x895cd7be) FF(a,b,c,d,M12,7,0x6b901122） FF(d,a,b,c,M13,12,0xfd987193） FF(c,d,a,b,M14,17,0xa679438e) FF(b,c,d,a,M15,22,0x49b40821） 第二轮 GG(a,b,c,d,M1,5,0xf61e2562） GG(d,a,b,c,M6,9,0xc040b340） GG(c,d,a,b,M11,14,0x265e5a51） GG(b,c,d,a,M0,20,0xe9b6c7aa) GG(a,b,c,d,M5,5,0xd62f105d) GG(d,a,b,c,M10,9,0x02441453） GG(c,d,a,b,M15,14,0xd8a1e681） GG(b,c,d,a,M4,20,0xe7d3fbc8） GG(a,b,c,d,M9,5,0x21e1cde6） GG(d,a,b,c,M14,9,0xc33707d6） GG(c,d,a,b,M3,14,0xf4d50d87） GG(b,c,d,a,M8,20,0x455a14ed) GG(a,b,c,d,M13,5,0xa9e3e905） GG(d,a,b,c,M2,9,0xfcefa3f8） GG(c,d,a,b,M7,14,0x676f02d9） GG(b,c,d,a,M12,20,0x8d2a4c8a) 第三轮 HH(a,b,c,d,M5,4,0xfffa3942） HH(d,a,b,c,M8,11,0x8771f681） HH(c,d,a,b,M11,16,0x6d9d6122） HH(b,c,d,a,M14,23,0xfde5380c) HH(a,b,c,d,M1,4,0xa4beea44） HH(d,a,b,c,M4,11,0x4bdecfa9） HH(c,d,a,b,M7,16,0xf6bb4b60） HH(b,c,d,a,M10,23,0xbebfbc70） HH(a,b,c,d,M13,4,0x289b7ec6） HH(d,a,b,c,M0,11,0xeaa127fa) HH(c,d,a,b,M3,16,0xd4ef3085） HH(b,c,d,a,M6,23,0x04881d05） HH(a,b,c,d,M9,4,0xd9d4d039） HH(d,a,b,c,M12,11,0xe6db99e5） HH(c,d,a,b,M15,16,0x1fa27cf8） HH(b,c,d,a,M2,23,0xc4ac5665） 第四轮 Ⅱ（a,b,c,d,M0,6,0xf4292244） Ⅱ（d,a,b,c,M7,10,0x432aff97） Ⅱ（c,d,a,b,M14,15,0xab9423a7） Ⅱ（b,c,d,a,M5,21,0xfc93a039） Ⅱ（a,b,c,d,M12,6,0x655b59c3） Ⅱ（d,a,b,c,M3,10,0x8f0ccc92） Ⅱ（c,d,a,b,M10,15,0xffeff47d) Ⅱ（b,c,d,a,M1,21,0x85845dd1） Ⅱ（a,b,c,d,M8,6,0x6fa87e4f) Ⅱ（d,a,b,c,M15,10,0xfe2ce6e0) Ⅱ（c,d,a,b,M6,15,0xa3014314） Ⅱ（b,c,d,a,M13,21,0x4e0811a1） Ⅱ（a,b,c,d,M4,6,0xf7537e82） Ⅱ（d,a,b,c,M11,10,0xbd3af235） Ⅱ（c,d,a,b,M2,15,0x2ad7d2bb) Ⅱ（b,c,d,a,M9,21,0xeb86d391）
MD5算法的c++实现
weixin_30832405的博客
11-16 135
需要注意的几点： （1）md5存取的数据长度仅为64位，位于数据的最前端，大于令其自然溢出。 （2）update函数和final函数处理得很繁琐，需要仔细分析。 （3）16位md5码取32位md5码的中间16位。 1、Md5.hpp #include<cstdio> #include<cstring> #include<algorithm> ...
利用C++实现md5算法
热门推荐
wudishine的专栏
01-06 2万+
因为需要校验文件，所以要使用md5算法，发现用python脚本生成文件的md5值不要太简单啊#-*- coding:utf-8 –*- import os,sys from hashlib import md5 #文件的MD5校验码是根据文件的内容生成的信息摘要，方法如下， def md5_file(name):     m = md5()     fd = open(name, 'r
md5(C++实现)
06-21
md5, 预留函数接口，可以改进
一种高效的md5算法的c++实现
04-26
一种高效的md5算法的c++实现,可以直接加载到你的工程中使用。你懂的！
MD5算法详解与C++实现
开发者可以使用预编译的库，如OpenSSL，或者编写自己的MD5实现。以下是一个简化的C++ MD5计算过程概述： ```cpp struct MD5Context { uint32_t state[4]; // 4个32位的变量用于存储中间结果 uint64_t count; // ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值