`

MD5 算法实现（c++）

    博客分类：
  • c++
 
阅读更多

用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);
}

 

分享到：
| 苹果推送机制APNs（二）
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    MD5 加密算法 C++实现源码

    在C++中实现MD5加密算法，通常包括以下几个步骤： 1. **初始化MD5状态**: 创建一个128位的缓冲区，用于存储中间结果，初始化为一组固定的常量。 2. **处理输入数据**: 将输入的明文数据按照512位的块进行处理。...

    MD5算法标准以及C++语言实现实例

    在提供的压缩包中，有两个源文件MD5.cpp和MD5.h，它们可能包含了MD5算法的C++实现。通常，`.cpp`文件包含具体的函数实现，而`.h`文件则定义了类和函数接口，供其他源文件引用。开发者可能已经编写了一个名为MD5的类...

    md5算法的c++实现

    看到一个不错的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); ...

    C++实现的MD5算法

    在C++中实现MD5算法，首先需要理解MD5的基本流程。MD5通过四个不同的处理步骤——初始化、压缩、填充和输出——来计算输入消息的哈希值。这四个步骤涉及到一系列的位操作、循环和特定的常量，确保了算法的复杂性和...

    实现MD5算法的C++源码

    优秀的C++ MD5实现应该考虑到不同平台的差异，如endianness（字节序），确保在大端和小端系统上都能正确运行。 9. 错误处理： 实现中可能会包含错误处理代码，比如检查输入数据的有效性，或者在内存不足等情况下...

    MD5加密算法C++实现

    在C++中实现MD5加密算法涉及到对原始数据进行特定的数学运算和位操作，生成一个128位（通常以32个十六进制数字表示）的唯一标识。 以下是对MD5加密算法的关键步骤和C++实现细节的详细介绍： 1. **初始化**: MD5...

    基于C++实现 MD5 算法的文件完整性校验程序【100010122】

    基于 MD5 算法的文件完整性校验程序，本实验使用 C++ 语言在 Linux 平台进行编程和运行。 ./md5 -h 查看帮助 ./md5 -t 打印程序的测试信息 ./md5 -c nankai.txt 计算出的被测文件的 MD5 摘要并打印 ./md5 -v nankai....

    MD5算法BCB模块

    这对于快速实现MD5计算功能非常方便，尤其适合那些不熟悉MD5算法底层实现的开发者。 Borland C++ Builder（简称BCB）是Embarcadero Technologies开发的一款集成开发环境，主要用于编写C++应用程序。Bcb6是其第六个...

    md5加密算法 C++源码

    总的来说，MD5加密算法在C++中的实现涉及到哈希函数的理解、位操作和循环结构的运用，以及可能的第三方库的集成。理解MD5的工作原理，结合C++编程技巧，可以有效地实现和应用这一重要的信息安全工具。

    MD5算法实现的C代码

    总的来说，这个项目提供了一个在VC++环境中实现MD5算法的实例，包括了用户界面交互、字符串处理和MD5哈希计算，是学习和理解MD5算法的一个实用平台。通过阅读和分析源代码，开发者可以深入理解MD5的工作原理，并掌握...

    一种高效的md5算法的c++实现

    下面将详细讲解MD5算法的原理以及C++实现的关键步骤。 MD5算法基于消息块处理和迭代过程。它将输入数据分块处理，每个块为512位，然后通过四个不同的函数F、G、H和I以及一系列的位操作、加法和异或运算来生成最终的...

    C++实现MD5算法程序设计与实现.zip

    资源包含文件：设计报告word+源码及可执行exe文件 ...MD5实现的基本过程为填充，分块，缓冲区初始化，循环压缩，得出结果。 详细介绍参考：https://blog.csdn.net/sheziqiong/article/details/125636590

    MD5算法C++实现

    "Md5Demo"可能是一个包含MD5算法C++实现的源代码文件，"说明.txt"可能是对这个实现的解释或使用指南。 对于逆向工程，MD5哈希的使用可以帮助识别已知的数据，比如在分析二进制文件或调试程序时，通过比较MD5值可以...

    md5加密算法的c++代码实现

    根据给定的文件信息，我们可以总结出以下关于“MD5加密算法的C++代码实现”的详细知识点： ### MD5加密算法简介 MD5（Message-Digest Algorithm 5）是一种广泛使用的散列函数，它可以将任意长度的信息转换为一个...

    MD5算法C++程序

    10. **代码实践**：实际编程中，你可以参考现有的开源MD5库，如OpenSSL的MD5实现，或者独立编写MD5函数，通过实践加深理解。 了解以上知识点后，你可以创建一个C++程序，读取任意文件并计算其MD5值，也可以将程序...

    IDEA ECC MD5 算法c++实现及报告

    C++实现MD5，需要理解其四个消息块处理阶段（初始化、压缩、更新和终止），以及每一步中的位操作和循环。 在提供的资源中，"IDEA报告.doc"和"ECC报告.doc"应包含了这两种加密算法的详细分析和实现过程，可以帮助...

    MD5 C++实现 对文件计算MD5值

    在C++中实现MD5算法，主要是为了获取文件的数字指纹，用于验证文件的完整性和一致性。 `GetFileMd5`函数的定义如下： ```cpp bool GetFileMd5(char *pMd5, const char *pFileName); ``` 这个函数接受两个参数：`...

    MD5算法的C++实现和调用程序

    在C++中实现MD5算法，你需要理解以下几个关键步骤： 1. **初始化**: MD5算法的初始状态由四个32位的整数（A, B, C, D）组成，它们的初始值是特定的十六进制数。 2. **处理块**: 输入数据被分割成连续的512位块。每...

Magicbox
Global site tag (gtag.js) - Google Analytics