精华内容
下载资源
问答
  • MD5验证文件完整性 C++

    千次阅读 2019-04-22 11:03:10
    为了验证下载的文件是否完整,是否被篡改,常用的验证方法为MD5验证,文件生成32位验证码,可验证文件是否完整下载或被篡改。 md5.h文件 #ifndef MD5_H #define MD5_H #include <string> #include <...

    读取文件内容并且做MD5验证 C++

    为了验证下载的文件是否完整,是否被篡改,常用的验证方法为MD5验证,文件生成32位验证码,可验证文件是否完整下载或被篡改。

    md5.h文件

    #ifndef MD5_H
    #define MD5_H
     
    #include <string>
    #include <fstream>
     
    /* Type define */
    typedef unsigned char byte;
    typedef unsigned int uint32;
     
    using std::string;
    using std::ifstream;
     
    /* MD5 declaration. */
    class MD5 {
    public:
    MD5();
    MD5(const void* input, size_t length);
    MD5(const string& str);
    MD5(ifstream& in);
    void update(const void* input, size_t length);
    void update(const string& str);
    void update(ifstream& in);
    const byte* digest();
    string toString();
    void reset();
     
    private:
    void update(const byte* input, size_t length);
    void final();
    void transform(const byte block[64]);
    void encode(const uint32* input, byte* output, size_t length);
    void decode(const byte* input, uint32* output, size_t length);
    string bytesToHexString(const byte* input, size_t length);
     
    /* class uncopyable */
    MD5(const MD5&);
    MD5& operator=(const MD5&);
     
    private:
    uint32 _state[4]; /* state (ABCD) */
    uint32 _count[2]; /* number of bits, modulo 2^64 (low-order word first) */
    byte _buffer[64]; /* input buffer */
    byte _digest[16]; /* message digest */
    bool _finished;   /* calculate finished ? */
     
    static const byte PADDING[64]; /* padding for calculate */
    static const char HEX[16];
    enum { BUFFER_SIZE = 1024 };
    };
     
    #endif /*MD5_H*/
    
    

    md5.cpp文件

    #include "md5.h"
     
    using namespace std;
     
    /* Constants for MD5Transform routine. */
    #define S11 7
    #define S12 12
    #define S13 17
    #define S14 22
    #define S21 5
    #define S22 9
    #define S23 14
    #define S24 20
    #define S31 4
    #define S32 11
    #define S33 16
    #define S34 23
    #define S41 6
    #define S42 10
    #define S43 15
    #define S44 21
     
     
    /* F, G, H and I are basic MD5 functions.
    */
    #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
    #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
    #define H(x, y, z) ((x) ^ (y) ^ (z))
    #define I(x, y, z) ((y) ^ ((x) | (~z)))
     
    /* ROTATE_LEFT rotates x left n bits.
    */
    #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
     
    /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
    Rotation is separate from addition to prevent recomputation.
    */
    #define FF(a, b, c, d, x, s, ac) { \
    (a) += F ((b), (c), (d)) + (x) + ac; \
    (a) = ROTATE_LEFT ((a), (s)); \
    (a) += (b); \
    }
    #define GG(a, b, c, d, x, s, ac) { \
    (a) += G ((b), (c), (d)) + (x) + ac; \
    (a) = ROTATE_LEFT ((a), (s)); \
    (a) += (b); \
    }
    #define HH(a, b, c, d, x, s, ac) { \
    (a) += H ((b), (c), (d)) + (x) + ac; \
    (a) = ROTATE_LEFT ((a), (s)); \
    (a) += (b); \
    }
    #define II(a, b, c, d, x, s, ac) { \
    (a) += I ((b), (c), (d)) + (x) + ac; \
    (a) = ROTATE_LEFT ((a), (s)); \
    (a) += (b); \
    }
     
     
    const byte MD5::PADDING[64] = { 0x80 };
    const char MD5::HEX[16] = {
    '0', '1', '2', '3',
    '4', '5', '6', '7',
    '8', '9', 'a', 'b',
    'c', 'd', 'e', 'f'
    };
     
     
    /* Default construct. */
    MD5::MD5() {
    reset();
    }
     
    /* Construct a MD5 object with a input buffer. */
    MD5::MD5(const void* input, size_t length) {
    reset();
    update(input, length);
    }
     
    /* Construct a MD5 object with a string. */
    MD5::MD5(const string& str) {
    reset();
    update(str);
    }
     
    /* Construct a MD5 object with a file. */
    MD5::MD5(ifstream& in) {
    reset();
    update(in);
    }
     
    /* Return the message-digest */
    const byte* MD5::digest() {
     
    if (!_finished) {
       _finished = true;
       final();
    }
    return _digest;
    }
     
    /* Reset the calculate state */
    void MD5::reset() {
     
    _finished = false;
    /* reset number of bits. */
    _count[0] = _count[1] = 0;
    /* Load magic initialization constants. */
    _state[0] = 0x67452301;
    _state[1] = 0xefcdab89;
    _state[2] = 0x98badcfe;
    _state[3] = 0x10325476;
    }
     
    /* Updating the context with a input buffer. */
    void MD5::update(const void* input, size_t length) {
    update((const byte*)input, length);
    }
     
    /* Updating the context with a string. */
    void MD5::update(const string& str) {
    update((const byte*)str.c_str(), str.length());
    }
     
    /* Updating the context with a file. */
    void MD5::update(ifstream& in) {
     
    if (!in) {
       return;
    }
     
    std::streamsize length;
    char buffer[BUFFER_SIZE];
    while (!in.eof()) {
       in.read(buffer, BUFFER_SIZE);
       length = in.gcount();
       if (length > 0) {
        update(buffer, length);
       }
    }
    in.close();
    }
     
    /* MD5 block update operation. Continues an MD5 message-digest
    operation, processing another message block, and updating the
    context.
    */
    void MD5::update(const byte* input, size_t length) {
     
    uint32 i, index, partLen;
     
    _finished = false;
     
    /* Compute number of bytes mod 64 */
    index = (uint32)((_count[0] >> 3) & 0x3f);
     
    /* update number of bits */
    if ((_count[0] += ((uint32)length << 3)) < ((uint32)length << 3)) {
       ++_count[1];
    }
    _count[1] += ((uint32)length >> 29);
     
    partLen = 64 - index;
     
    /* transform as many times as possible. */
    if (length >= partLen) {
     
       memcpy(&_buffer[index], input, partLen);
       transform(_buffer);
     
       for (i = partLen; i + 63 < length; i += 64) {
        transform(&input[i]);
       }
       index = 0;
     
    } else {
       i = 0;
    }
     
    /* Buffer remaining input */
    memcpy(&_buffer[index], &input[i], length - i);
    }
     
    /* MD5 finalization. Ends an MD5 message-_digest operation, writing the
    the message _digest and zeroizing the context.
    */
    void MD5::final() {
     
    byte bits[8];
    uint32 oldState[4];
    uint32 oldCount[2];
    uint32 index, padLen;
     
    /* Save current state and count. */
    memcpy(oldState, _state, 16);
    memcpy(oldCount, _count, 8);
     
    /* Save number of bits */
    encode(_count, bits, 8);
     
    /* Pad out to 56 mod 64. */
    index = (uint32)((_count[0] >> 3) & 0x3f);
    padLen = (index < 56) ? (56 - index) : (120 - index);
    update(PADDING, padLen);
     
    /* Append length (before padding) */
    update(bits, 8);
     
    /* Store state in digest */
    encode(_state, _digest, 16);
     
    /* Restore current state and count. */
    memcpy(_state, oldState, 16);
    memcpy(_count, oldCount, 8);
    }
     
    /* MD5 basic transformation. Transforms _state based on block. */
    void MD5::transform(const byte block[64]) {
     
    uint32 a = _state[0], b = _state[1], c = _state[2], d = _state[3], x[16];
     
    decode(block, x, 64);
     
    /* Round 1 */
    FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
    FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
    FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
    FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
    FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
    FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
    FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
    FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
    FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
    FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
    FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
    FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
    FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
    FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
    FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
    FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
     
    /* Round 2 */
    GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
    GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
    GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
    GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
    GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
    GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
    GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
    GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
    GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
    GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
    GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
    GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
    GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
    GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
    GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
    GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
     
    /* Round 3 */
    HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
    HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
    HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
    HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
    HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
    HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
    HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
    HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
    HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
    HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
    HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
    HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
    HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
    HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
    HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
    HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
     
    /* Round 4 */
    II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
    II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
    II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
    II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
    II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
    II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
    II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
    II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
    II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
    II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
    II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
    II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
    II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
    II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
    II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
    II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
     
    _state[0] += a;
    _state[1] += b;
    _state[2] += c;
    _state[3] += d;
    }
     
    /* Encodes input (ulong) into output (byte). Assumes length is
    a multiple of 4.
    */
    void MD5::encode(const uint32* input, byte* output, size_t length) {
     
    for (size_t i = 0, j = 0; j < length; ++i, j += 4) {
       output[j]= (byte)(input[i] & 0xff);
       output[j + 1] = (byte)((input[i] >> 8) & 0xff);
       output[j + 2] = (byte)((input[i] >> 16) & 0xff);
       output[j + 3] = (byte)((input[i] >> 24) & 0xff);
    }
    }
     
    /* Decodes input (byte) into output (ulong). Assumes length is
    a multiple of 4.
    */
    void MD5::decode(const byte* input, uint32* output, size_t length) {
     
    for (size_t i = 0, j = 0; j < length; ++i, j += 4) {
       output[i] = ((uint32)input[j]) | (((uint32)input[j + 1]) << 8) |
       (((uint32)input[j + 2]) << 16) | (((uint32)input[j + 3]) << 24);
    }
    }
     
    /* Convert byte array to hex string. */
    string MD5::bytesToHexString(const byte* input, size_t length) {
     
    string str;
    str.reserve(length << 1);
    for (size_t i = 0; i < length; ++i) {
       int t = input[i];
       int a = t / 16;
       int b = t % 16;
       str.append(1, HEX[a]);
       str.append(1, HEX[b]);
    }
    return str;
    }
     
    /* Convert digest to string value */
    string MD5::toString() {
    return bytesToHexString(digest(), 16);
    }
    
    

    read.cpp(写main函数)

    #include "md5.h"
    #include <iostream>
    #include <fstream>
    using namespace std;
    
    void PrintMD5(const string& str, MD5& md5) {
          cout << "MD5("" << str << "") = " << md5.toString() << endl;
    }
    
    string getFile(char* path)
    {
    	 unsigned char buf[4096*10]={0};
    	//memset(buf,0,50); "e://test.txt"
    	FILE *f=fopen(path,"rb+");
    	if(f==NULL){
    	 printf("路径错误,请核对...");
    	}
    	int len =fread(buf,1,4096*100,f);
    	fclose(f);
    	string hex;
    	for(int i = 0;i<len;i++){
    		 unsigned char buf[50]={0};
    		sprintf((char*)buf,"%02x",buf[i]);
    		hex.append((char*)buf);
    	}
    	string hashBuf =(char*)buf;
    	MD5 md5;
    	md5.update(hashBuf);
    	PrintMD5(path,md5);
    	md5.reset();
    	return 0;
    }
    
    void main()
    {
    	getFile("E://00.jpg");
    	system("pause");
    }
    

    MD5可为任何文件做验证,要求文件按照二进制读取文件。并非所有的文件内容都可见。
    在这里插入图片描述

    展开全文
  • java中使用MD5验证文件完整性

    千次阅读 2017-07-31 11:07:17
    在java中验证文件完整性的算法很多,不过今天我们只介绍一下使用MD5如何验证文件完整性;  public static void main(String[] args) throws IOException {  long begin = System.currentTimeMillis()

    在有关文件上传,下载时为了保证文件的安全和完整性都会考虑到验证文件的完整性操作。

    在java中验证文件完整性的算法很多,不过今天我们只介绍一下使用MD5如何验证文件完整性;


        public static void main(String[] args) throws IOException {

     long begin = System.currentTimeMillis();
     
            File file = new File("E:/unicom.sql");
            String md5 = getFileMD5String(file);
            
            //文件名不同,内容相同;
            File file2 = new File("E:/unicom1.txt");
            String md52= getFileMD5String(file2);
            
            File file6 = new File("E:/unicom1.rar");
            String md56= getFileMD5String(file6);
            
            //文件名不同,内容不同;
            File file3 = new File("E:/unicom2.sql");
            String md53= getFileMD5String(file3);
            
          
            //测试压缩包
            File fileZip = new File("E:/mybatis-generator-core-1.3.2(1).zip");
            String md5Zip= getFileMD5String(fileZip);
            
            //测试压缩包
            File fileZip2 = new File("E:/mybatis-generator-core-1.3.2.jar");
            String md5Zip2= getFileMD5String(fileZip2);
               
            System.out.println("MD5:"+md5);
            System.out.println("MD5:"+md52);
            System.out.println("MD5:"+md56);
            System.out.println("MD5:"+md53);
            System.out.println("MD5:"+md5Zip);
            System.out.println("MD5:"+md5Zip2);
            System.out.println("两个文件名不同,内同相同"+ checkPassword(md5, md52));
            System.out.println("文件名不同,内容不同"+ checkPassword(md5, md53));
            System.out.println("测试压缩包,内容不同"+ checkPassword(md5Zip, md5Zip2));

    }


    输出:

    MD5:4d4a4a9a42863f5a1e3e3afb055e0d04
    MD5:4d4a4a9a42863f5a1e3e3afb055e0d04
    MD5:f7a6626347f8a104f99abb67c3297215
    MD5:cad1f74a763045a5fe3d51cfeac23e50
    MD5:2021e31fe251d6864dfb333aa58c87e6
    MD5:2021e31fe251d6864dfb333aa58c87e6
    两个文件名不同,内同相同true
    文件名不同,内容不同false
    测试压缩包,内容不同true



    /**
         * 生成文件的md5校验值
         * 
         * @param file
         * @return
         * @throws IOException
         */
        public static String getFileMD5String(File file) throws IOException {       
            InputStream fis;
            fis = new FileInputStream(file);
            byte[] buffer = new byte[1024];
            int numRead = 0;
            while ((numRead = fis.read(buffer)) > 0) {
                messagedigest.update(buffer, 0, numRead);
            }
            fis.close();
            return bufferToHex(messagedigest.digest());
        }

      private static String bufferToHex(byte bytes[]) {
            return bufferToHex(bytes, 0, bytes.length);
        }

     private static String bufferToHex(byte bytes[], int m, int n) {
            StringBuffer stringbuffer = new StringBuffer(2 * n);
            int k = m + n;
            for (int l = m; l < k; l++) {
                appendHexPair(bytes[l], stringbuffer);
            }
            return stringbuffer.toString();
        }

     /**
         * 默认的密码字符串组合,用来将字节转换成 16 进制表示的字符,apache校验下载的文件的正确性用的就是默认的这个组合
         */
        protected static char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };


        private static void appendHexPair(byte bt, StringBuffer stringbuffer) {
            char c0 = hexDigits[(bt & 0xf0) >> 4];// 取字节中高 4 位的数字转换, >>> 为逻辑右移,将符号位一起右移,此处未发现两种符号有何不同 
            char c1 = hexDigits[bt & 0xf];// 取字节中低 4 位的数字转换 
            stringbuffer.append(c0);
            stringbuffer.append(c1);
        }

    展开全文
  • 利用md5算法进行验证数据完整性 md5sum -c 指纹文件命令执行原理 第一个历程: 打开一个指纹文件,将信息记录到缓存中 第二个历程: 根据指纹文件的路径信息,生成md5数值信息 第三个历程: 将新生成md5数值和原有...

    如何验证数据完整性
             利用md5算法进行验证数据完整性
             md5sum -c 指纹文件命令执行原理
             第一个历程: 打开一个指纹文件,将信息记录到缓存中
             第二个历程: 根据指纹文件的路径信息,生成md5数值信息
             第三个历程: 将新生成md5数值和原有指纹文件中的数值进行比较
             第四个历程: 如果相同显示结果为ok,如果不同显示failed

    展开全文
  • MD5验证上传文件完整性

    万次阅读 2015-08-18 15:02:12
    怎么样能保证资源的完整性,处理办法就是用MD5验证文件完整性。  任何一个字符串或文件,无论是可执行程序、图像文件、临时文件或者其他任何类型的文件,也不管它体积多大,都有且只有一个独一无二的MD5信息码,...

    在项目的开发资源开发中,测试发现一个问题:将资源上传到服务器上,提示已经上传成功,但是当打开这个文件时发现失败,由于各种原因资源已经毁坏。怎么样能保证资源的完整性,处理办法就是用MD5验证文件的完整性。
         任何一个字符串或文件,无论是可执行程序、图像文件、临时文件或者其他任何类型的文件,也不管它体积多大,都有且只有一个独一无二的MD5信息码,并且如果这个文件被修改过,它的MD5码也将随之改变。
           Message-Digest泛指字节串(Message)的Hash变换,就是把一个任意长度的字节串变换成一定长的大整数。注意这里说的是“字节串”而不是“字符串”,因为这种变换只与字节的值有关,与字符集或编码方式无关。
          在Java中,java.security.MessageDigest (rt.jar中)已经定义了 MD5 的计算,所以我们只需要简单地调用即可得到 MD5 的128 位整数。然后将此 128 位计 16 个字节转换成 16 进制表示即可。


    import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    
    public class TestMD5Two {
             /**
         * 默认的密码字符串组合,用来将字节转换成 16 进制表示的字符,apache校验下载的文件的正确性用的就是默认的这个组合
         */
        protected static char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6',
                '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
     
        protected static MessageDigest messagedigest = null;
        static {
            try {
                messagedigest = MessageDigest.getInstance("MD5");
            } catch (NoSuchAlgorithmException nsaex) {
                System.err.println(TestMD5Two.class.getName()
                        + "初始化失败,MessageDigest不支持MD5Util。");
                nsaex.printStackTrace();
            }
        }
         
        /**
         * 生成字符串的md5校验值
         * 
         * @param s
         * @return
         */
        public static String getMD5String(String s) {
            return getMD5String(s.getBytes());
        }
         
        /**
         * 判断字符串的md5校验码是否与一个已知的md5码相匹配
         * 
         * @param password 要校验的字符串
         * @param md5PwdStr 已知的md5校验码
         * @return
         */
        public static boolean checkPassword(String md5, String md5PwdStr) {
            return md5.equals(md5PwdStr);
        }
         
        /**
         * 生成文件的md5校验值
         * 
         * @param file
         * @return
         * @throws IOException
         */
        public static String getFileMD5String(File file) throws IOException {       
            InputStream fis;
            fis = new FileInputStream(file);
            byte[] buffer = new byte[1024];
            int numRead = 0;
            while ((numRead = fis.read(buffer)) > 0) {
                messagedigest.update(buffer, 0, numRead);
            }
            fis.close();
            return bufferToHex(messagedigest.digest());
        }
     
        public static String getMD5String(byte[] bytes) {
            messagedigest.update(bytes);
            return bufferToHex(messagedigest.digest());
        }
     
        private static String bufferToHex(byte bytes[]) {
            return bufferToHex(bytes, 0, bytes.length);
        }
     
        private static String bufferToHex(byte bytes[], int m, int n) {
            StringBuffer stringbuffer = new StringBuffer(2 * n);
            int k = m + n;
            for (int l = m; l < k; l++) {
                appendHexPair(bytes[l], stringbuffer);
            }
            return stringbuffer.toString();
        }
     
        private static void appendHexPair(byte bt, StringBuffer stringbuffer) {
            char c0 = hexDigits[(bt & 0xf0) >> 4];// 取字节中高 4 位的数字转换, >>> 为逻辑右移,将符号位一起右移,此处未发现两种符号有何不同 
            char c1 = hexDigits[bt & 0xf];// 取字节中低 4 位的数字转换 
            stringbuffer.append(c0);
            stringbuffer.append(c1);
        }
         
        public static void main(String[] args) throws IOException {
            long begin = System.currentTimeMillis();
     
            File file = new File("H:/12345.txt");
            String md5 = getFileMD5String(file);
            
            //文件名不同,内容相同;
            File file2 = new File("H:/12345(2).txt");
            String md52= getFileMD5String(file2);
            
            
            //文件名不同,内容不同;
            File file3 = new File("H:/12345(3).txt");
            String md53= getFileMD5String(file3);
            
          
            //测试压缩包
            File fileZip = new File("H:/1.zip");
            String md5Zip= getFileMD5String(fileZip);
            
            //测试压缩包
            File fileZip2 = new File("H:/2.zip");
            String md5Zip2= getFileMD5String(fileZip2);
               
            System.out.println("MD5:"+md5);
            System.out.println("MD5:"+md52);
            System.out.println("MD5:"+md53);
            System.out.println("MD5:"+md5Zip);
            System.out.println("MD5:"+md5Zip2);
                    System.out.println("两个文件名不同,内同相同"+ checkPassword(md5, md52));
                    System.out.println("文件名不同,内容不同"+ checkPassword(md5, md53));
                    System.out.println("测试压缩包,内容不同"+ checkPassword(md5Zip, md5Zip2));
             
            long end = System.currentTimeMillis();
            System.out.println("md5:" + md5 + " time:" + ((end - begin) / 1000) + "s");
        }
    }
    


    展开全文
  • JAVA MD5验证上传文件完整性

    千次阅读 2018-05-19 15:05:08
    * 生成文件md5校验值 * * @param file * @return * @throws IOException */ public static String getFileMD5String (File file) throws IOException { InputStream fis; fis = new ...
  • java 中MD5验证文件一致

    千次阅读 2015-12-29 10:06:11
    MD5现在是用来作为一种数字签名算法,即A向B发送数据m,为了让B确信数据是A送来的并且没有被篡改于是A就是用hash算法将数据散列一并发送给 B。B接收到文件以后也用相同的hash算法校验数据是否被修改。主要是防止数据...
  • md5和sha1文件完整性校验

    千次阅读 2019-09-12 19:19:20
    简单而强大的命令:md5sum/sha1sum。...官方提供了md5/sha1文件完整性校验码,如何使用这两个文件进行校验是本文的目的。 md5sum校验 md5sum是Linux系统自带的命令,windows系统安装了bash shell也可以使用该命令。...
  • MD5进行文件完整性校验的操作方法

    千次阅读 2017-10-23 11:27:00
    我组产品包含大量音频和图片资源,MD5主要就用来检测这些资源文件完整性。主要思路是:先计算出所有资源文件MD5值,存到一个xml文件中,作为标准的MD5值。然后把这个xml文件放到我们的产品中,每次更新程序以后...
  • Linux下md5sum 校验文件完整性

    千次阅读 2018-01-24 15:55:07
     MD5算法常常被用来验证网络文件传输的完整性,防止文件被人篡改。MD5 全称是报文摘要算法(Message-Digest Algorithm 5),此算法对任意长度的信息逐位进行计算,产生一个二进制长度为128位(十六进制长度就是32位...
  • gpg、sha512sum或md5sum验证完整性

    千次阅读 2019-03-10 23:18:39
    PGP签名(.asc文件) PGP(英语:Pretty Good Privacy,中文翻译“优良保密协议”)是一套用于消息加密、验证的应用程序,采用IDEA的散列算法作为加密与验证之用,以RSA公钥&amp;私钥及AES(Advanced Encryption...
  • 基本概念MD5算法可以被用来验证文件完整性和是否被篡改。MD5 全称是报文摘要算法(Message-Digest Algorithm 5),通过对任意长度的信息逐位进行计算,产生一个二进制长度为128位(十六进制长度就是32位)的 hash ...
  • md5算法检测文件完整性

    千次阅读 2013-01-25 11:32:36
    MD5算法常常被用来验证网络文件传输的完整性,防止文件被人篡改。 MD5全称是报文摘要算法(Message-Digest Algorithm5) 此算法对任意长度的信息逐位进行计算,产生一个二进制长度为128位(十六进制长度就是32位)...
  • linux下md5sum 校验文件完整性

    千次阅读 2014-03-11 10:34:51
     MD5算法常常被用来验证网络文件传输的完整性,防止文件被人篡改。MD5 全称是报文摘要算法(Message-Digest Algorithm 5),此算法对任意长度的信息逐位进行计算,产生一个二进制长度为128位(十六进制长度就是32位...
  • MD5】校验下载文件完整性

    千次阅读 2019-06-15 01:14:50
    一般文件过大,随文件会赋给你一个 MD5 值用于检验下载的文件是否完整 需要校验的文件 文件附带的 MD5 值 Windows 10 windows + R 运行 cmd 执行如下命令,其中 path/file 是你文件的路径 certutil -...
  • 使用文件Md5值检测文件完整性

    千次阅读 2018-08-09 15:01:52
    为了解决这个问题,博主第一次了解到文件Md5值这个概念(技术小白还在成长中,见谅见谅),所以有了这篇博客。  首先介绍一下几个相关概念:  MD5算法:是计算机广泛使用的一种哈希算法,将数据(如汉字)运算...
  • 对于大的文件,比如大型游戏,下载一般会带有md5值在下载包里面,md5是一种加密手段,在这里可以用来验证完整性,因为在下载大型文件的时候某个部分可能网络传输会出现错误,一个小文件坏了可能会导致游戏玩到中间出...
  • MD5算法常常被用来验证网络文件传输的完整性,防止文件被人篡改。MD5 全称是报文摘要算法(Message-Digest Algorithm 5),此算法对任意长度的信息逐位进行计算,产生一个二进制长度为128位(十六进制长度就是32位)...
  • 标签:Windows,windows,文件完整性,数字摘要值,MD5md5,SHA,SHA1,SHA256。 目录修订历史说明 修订历史 2020-07-10:首次编辑。 说明 当获取一个文件后,有时需要验证它的完整性(主要是验证其是否被修改)...
  • android对文件MD5验证

    热门讨论 2010-08-31 18:09:41
    能够独立编译运行的android的MD5验证程序
  • 验证数据完整性-MD5算法

    千次阅读 2011-11-15 15:20:50
    [quote]MD5 -- message-digest algorithm 5 (信息-摘要算法)缩写,广泛用于加密和解密技术,常用于文件校验。校验?不管文件多大,经过MD5后都能生成唯一的MD5值。...就是用来验证文件是否一致的。 [/quote...
  • md5sum 和 sha256sum用于 验证软件完整性 https://www.cnblogs.com/xuyaowen/p/md5sum_sha256_usages.html md5sum 和 sha256sum 都用来用来校验软件安装包的完整性,本次我们将讲解如何使用两个命令进行软件安装包...
  • Windows校验文件完整性MD5

    千次阅读 2020-04-23 11:34:52
    数据在传输过程中可能会有丢失或者误码或者被篡改等可能(对我来说最重要的是检验有没有被篡改,放木马后门什么的),所以检验文件完整性非常重要,一般很多软件工具官网都会提供文件的md5值或者SHA256等校验值...
  • MD5:一种被广泛使用的密码散列函数,可以产生出一个128位(16字节)的散列值(hash value),用于确保信息传输完整一致,是一种不可逆的摘要算法,用于生成摘要,无法逆破解到原文。 Base64:是从二进制到字符的...
  • 我们经常用以下命令来验证数据的完整性。 $ md5sum / path / filename $ sha256sum / path / filename 注意:替换/path/filename为您下载的文件的实际路径和文件名。 使用 Microsoft网站上的免费在线验证工具...
  • MAC查看MD5值 1.打开终端 2.输入 md5filename 3.将需要校验的文件拖入终端窗口(这一步就是相当于输入文件的目录地址) 4.按下回车,等待返回结果(文件越大,校验越慢) WIN查看MD5值 certutil -hashfile ...
  • MD5MD5校验文件的正确

    万次阅读 2017-12-04 20:07:31
    也要确保war包,在上传过程中没有发生缺包状况,保证war包的完整性。原理MD5值是一串hash值,文件只要有任何字节变动,MD5值就会跟着改变,因此可以作为校验文件的依据。 在前端输入MD5值,选中要
  • 最近文件完整性校验由MD5变成了sha256, 对于选择sha256这个hash算法的原因从网上找了一些资料。一句话概括:sha256更加安全一些。http://bobao.360.cn/learning/detail/564.htmlMD5哈希算法使用比较广泛,很多年前就...
  • 在Linux上使用PGP签名验证文件完整性

    万次阅读 2017-08-11 20:04:37
    所以,在使用一个文件之前(如安装一个软件或操作系统)最好先对文件进行完整性(或者说“原始性”)的检验。常用的文件校验方法有SHA、MD5、CRC和PGP签名等。本文主要阐述一下在Linux上使用P...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,993
精华内容 15,597
关键字:

md5验证文件完整性