开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
md5.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：11k
源码类别：

生物技术

开发平台：

C/C++

md5.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: md5.cpp,v $
  4.  * PRODUCTION Revision 1000.1  2004/06/01 19:40:16  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.6
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: md5.cpp,v 1000.1 2004/06/01 19:40:16 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Author:  Aaron Ucko (C++ interface); original author unknown
  36.  *
  37.  * File Description:
  38.  *   CMD5 - class for computing Message Digest version 5 checksums.
  39.  *
  40.  */
  42. #include <ncbi_pch.hpp>
  43. #include <util/md5.hpp>
  44. #include <util/util_exception.hpp>
  47. BEGIN_NCBI_SCOPE
  50. // Note: this code is harmless on little-endian machines.
  51. inline
  52. static void s_ByteReverse(unsigned char* buf, size_t longs)
  53. {
  54.     Uint4 t;
  55.     do {
  56.         t = (Uint4) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
  57.             ((unsigned) buf[1] << 8 | buf[0]);
  58.         *(reinterpret_cast<Uint4*>(buf)) = t;
  59.         buf += 4;
  60.     } while (--longs);
  61. }
  64. // Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
  65. // initialization constants.
  66. CMD5::CMD5(void)
  67.     : m_Bits(0), m_Finalized(false)
  68. {
  69.     m_Buf[0] = 0x67452301;
  70.     m_Buf[1] = 0xefcdab89;
  71.     m_Buf[2] = 0x98badcfe;
  72.     m_Buf[3] = 0x10325476;
  73. }
  76. // Update state to reflect the concatenation of another buffer full of bytes.
  77. void CMD5::Update(const char* buf, size_t length)
  78. {
  79.     if ( m_Finalized ) {
  80.         NCBI_THROW(CUtilException, eWrongCommand,
  81.                    "attempt to update a finalized MD5 instance");
  82.     }
  84.     // Number of leftover bytes in m_In
  85.     unsigned int tmp = (unsigned int)((m_Bits >> 3) % sizeof(m_In));
  86.     
  87.     // Update bit count
  88.     m_Bits += length << 3;
  90.     // Handle any leading odd-sized chunks
  91.     if ( tmp ) {
  92.         unsigned char* p = m_In + tmp;
  94.         tmp = kBlockSize - tmp;
  95.         if (length < tmp) {
  96.             memcpy(p, buf, length);
  97.             return;
  98.         }
  99.         memcpy(p, buf, tmp);
  100. #ifdef WORDS_BIGENDIAN
  101.         s_ByteReverse(m_In, 16);
  102. #endif
  103.         Transform();
  104.         buf    += tmp;
  105.         length -= tmp;
  106.     }
  108.     // Process remaining data in kBlockSize-byte chunks
  109.     while (length >= kBlockSize) {
  110.         memcpy(m_In, buf, kBlockSize);
  111. #ifdef WORDS_BIGENDIAN
  112.         s_ByteReverse(m_In, 16);
  113. #endif
  114.         Transform();
  115.         buf    += kBlockSize;
  116.         length -= kBlockSize;
  117.     }
  119.     // Handle any remaining bytes of data
  120.     memcpy(m_In, buf, length);
  121. }
  124. // Final wrapup - pad to kBlockSize-byte boundary with the bit pattern
  125. // 1 0* (64-bit count of bits processed, MSB-first).
  126. void CMD5::Finalize(unsigned char digest[16])
  127. {
  128.     if ( m_Finalized ) {
  129.         memcpy(digest, m_Buf, 16);
  130.         return;
  131.     }
  133.     // Compute number of bytes mod kBlockSize
  134.     int count = (int)((m_Bits >> 3) % kBlockSize);
  136.     // Set the first char of padding to 0x80.  This is safe since there is
  137.     // always at least one byte free.
  138.     unsigned char *p = m_In + count;
  139.     *p++ = 0x80;
  141.     // Bytes of padding needed to make kBlockSize bytes
  142.     count = kBlockSize - 1 - count;
  144.     // Pad out to 56 mod kBlockSize
  145.     if (count < 8) {
  146.         // Two lots of padding:  Pad the first block to kBlockSize bytes
  147.         memset(p, 0, count);
  148. #ifdef WORDS_BIGENDIAN
  149.         s_ByteReverse(m_In, 16);
  150. #endif
  151.         Transform();
  153.         // Now fill the next block with 56 bytes
  154.         memset(m_In, 0, kBlockSize - 8);
  155.     } else {
  156.         // Pad block to 56 bytes
  157.         memset(p, 0, count - 8);
  158. #ifdef WORDS_BIGENDIAN
  159.         s_ByteReverse(m_In, 14);
  160. #endif
  161.     }
  163.     // Append length in bits and transform
  164.     reinterpret_cast<Uint4*>(m_In)[14] = static_cast<Uint4>(m_Bits);
  165.     reinterpret_cast<Uint4*>(m_In)[15] = static_cast<Uint4>(m_Bits >> 32);
  167.     Transform();
  168. #ifdef WORDS_BIGENDIAN
  169.     s_ByteReverse(reinterpret_cast<unsigned char*>(m_Buf), 4);
  170. #endif
  171.     memcpy(digest, m_Buf, 16);
  172.     memset(m_In, 0, kBlockSize); // may be sensitive
  173. }
  176. string CMD5::GetHexSum(unsigned char digest[16])
  177. {
  178.     CNcbiOstrstream oss;
  179.     for (size_t i = 0; i < 16; ++i) {
  180.         oss << hex << setw(2) << setfill('0') << (int)digest[i];
  181.     }
  182.     return CNcbiOstrstreamToString(oss);
  183. }
  186. // The four core functions - F1 is optimized somewhat
  188. // #define F1(x, y, z) (x & y | ~x & z)
  189. #define F1(x, y, z) (z ^ (x & (y ^ z)))
  190. #define F2(x, y, z) F1(z, x, y)
  191. #define F3(x, y, z) (x ^ y ^ z)
  192. #define F4(x, y, z) (y ^ (x | ~z))
  194. // This is the central step in the MD5 algorithm.
  195. #define MD5STEP(f, w, x, y, z, data, s) 
  196.         ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
  198. // The core of the MD5 algorithm, this alters an existing MD5 hash to
  199. // reflect the addition of 16 longwords of new data.  MD5Update blocks
  200. // the data and converts bytes into longwords for this routine.
  201. void CMD5::Transform(void)
  202. {
  203.     Uint4  a, b, c, d;
  204.     Uint4* inw = reinterpret_cast<Uint4*>(m_In);
  206.     a = m_Buf[0];
  207.     b = m_Buf[1];
  208.     c = m_Buf[2];
  209.     d = m_Buf[3];
  211.     MD5STEP(F1, a, b, c, d, inw[0]  + 0xd76aa478,  7);
  212.     MD5STEP(F1, d, a, b, c, inw[1]  + 0xe8c7b756, 12);
  213.     MD5STEP(F1, c, d, a, b, inw[2]  + 0x242070db, 17);
  214.     MD5STEP(F1, b, c, d, a, inw[3]  + 0xc1bdceee, 22);
  215.     MD5STEP(F1, a, b, c, d, inw[4]  + 0xf57c0faf,  7);
  216.     MD5STEP(F1, d, a, b, c, inw[5]  + 0x4787c62a, 12);
  217.     MD5STEP(F1, c, d, a, b, inw[6]  + 0xa8304613, 17);
  218.     MD5STEP(F1, b, c, d, a, inw[7]  + 0xfd469501, 22);
  219.     MD5STEP(F1, a, b, c, d, inw[8]  + 0x698098d8,  7);
  220.     MD5STEP(F1, d, a, b, c, inw[9]  + 0x8b44f7af, 12);
  221.     MD5STEP(F1, c, d, a, b, inw[10] + 0xffff5bb1, 17);
  222.     MD5STEP(F1, b, c, d, a, inw[11] + 0x895cd7be, 22);
  223.     MD5STEP(F1, a, b, c, d, inw[12] + 0x6b901122,  7);
  224.     MD5STEP(F1, d, a, b, c, inw[13] + 0xfd987193, 12);
  225.     MD5STEP(F1, c, d, a, b, inw[14] + 0xa679438e, 17);
  226.     MD5STEP(F1, b, c, d, a, inw[15] + 0x49b40821, 22);
  228.     MD5STEP(F2, a, b, c, d, inw[1]  + 0xf61e2562,  5);
  229.     MD5STEP(F2, d, a, b, c, inw[6]  + 0xc040b340,  9);
  230.     MD5STEP(F2, c, d, a, b, inw[11] + 0x265e5a51, 14);
  231.     MD5STEP(F2, b, c, d, a, inw[0]  + 0xe9b6c7aa, 20);
  232.     MD5STEP(F2, a, b, c, d, inw[5]  + 0xd62f105d,  5);
  233.     MD5STEP(F2, d, a, b, c, inw[10] + 0x02441453,  9);
  234.     MD5STEP(F2, c, d, a, b, inw[15] + 0xd8a1e681, 14);
  235.     MD5STEP(F2, b, c, d, a, inw[4]  + 0xe7d3fbc8, 20);
  236.     MD5STEP(F2, a, b, c, d, inw[9]  + 0x21e1cde6,  5);
  237.     MD5STEP(F2, d, a, b, c, inw[14] + 0xc33707d6,  9);
  238.     MD5STEP(F2, c, d, a, b, inw[3]  + 0xf4d50d87, 14);
  239.     MD5STEP(F2, b, c, d, a, inw[8]  + 0x455a14ed, 20);
  240.     MD5STEP(F2, a, b, c, d, inw[13] + 0xa9e3e905,  5);
  241.     MD5STEP(F2, d, a, b, c, inw[2]  + 0xfcefa3f8,  9);
  242.     MD5STEP(F2, c, d, a, b, inw[7]  + 0x676f02d9, 14);
  243.     MD5STEP(F2, b, c, d, a, inw[12] + 0x8d2a4c8a, 20);
  245.     MD5STEP(F3, a, b, c, d, inw[5]  + 0xfffa3942,  4);
  246.     MD5STEP(F3, d, a, b, c, inw[8]  + 0x8771f681, 11);
  247.     MD5STEP(F3, c, d, a, b, inw[11] + 0x6d9d6122, 16);
  248.     MD5STEP(F3, b, c, d, a, inw[14] + 0xfde5380c, 23);
  249.     MD5STEP(F3, a, b, c, d, inw[1]  + 0xa4beea44,  4);
  250.     MD5STEP(F3, d, a, b, c, inw[4]  + 0x4bdecfa9, 11);
  251.     MD5STEP(F3, c, d, a, b, inw[7]  + 0xf6bb4b60, 16);
  252.     MD5STEP(F3, b, c, d, a, inw[10] + 0xbebfbc70, 23);
  253.     MD5STEP(F3, a, b, c, d, inw[13] + 0x289b7ec6,  4);
  254.     MD5STEP(F3, d, a, b, c, inw[0]  + 0xeaa127fa, 11);
  255.     MD5STEP(F3, c, d, a, b, inw[3]  + 0xd4ef3085, 16);
  256.     MD5STEP(F3, b, c, d, a, inw[6]  + 0x04881d05, 23);
  257.     MD5STEP(F3, a, b, c, d, inw[9]  + 0xd9d4d039,  4);
  258.     MD5STEP(F3, d, a, b, c, inw[12] + 0xe6db99e5, 11);
  259.     MD5STEP(F3, c, d, a, b, inw[15] + 0x1fa27cf8, 16);
  260.     MD5STEP(F3, b, c, d, a, inw[2]  + 0xc4ac5665, 23);
  262.     MD5STEP(F4, a, b, c, d, inw[0]  + 0xf4292244,  6);
  263.     MD5STEP(F4, d, a, b, c, inw[7]  + 0x432aff97, 10);
  264.     MD5STEP(F4, c, d, a, b, inw[14] + 0xab9423a7, 15);
  265.     MD5STEP(F4, b, c, d, a, inw[5]  + 0xfc93a039, 21);
  266.     MD5STEP(F4, a, b, c, d, inw[12] + 0x655b59c3,  6);
  267.     MD5STEP(F4, d, a, b, c, inw[3]  + 0x8f0ccc92, 10);
  268.     MD5STEP(F4, c, d, a, b, inw[10] + 0xffeff47d, 15);
  269.     MD5STEP(F4, b, c, d, a, inw[1]  + 0x85845dd1, 21);
  270.     MD5STEP(F4, a, b, c, d, inw[8]  + 0x6fa87e4f,  6);
  271.     MD5STEP(F4, d, a, b, c, inw[15] + 0xfe2ce6e0, 10);
  272.     MD5STEP(F4, c, d, a, b, inw[6]  + 0xa3014314, 15);
  273.     MD5STEP(F4, b, c, d, a, inw[13] + 0x4e0811a1, 21);
  274.     MD5STEP(F4, a, b, c, d, inw[4]  + 0xf7537e82,  6);
  275.     MD5STEP(F4, d, a, b, c, inw[11] + 0xbd3af235, 10);
  276.     MD5STEP(F4, c, d, a, b, inw[2]  + 0x2ad7d2bb, 15);
  277.     MD5STEP(F4, b, c, d, a, inw[9]  + 0xeb86d391, 21);
  279.     m_Buf[0] += a;
  280.     m_Buf[1] += b;
  281.     m_Buf[2] += c;
  282.     m_Buf[3] += d;
  283. }
  286. END_NCBI_SCOPE
  289. /*
  290.  * ===========================================================================
  291.  * $Log: md5.cpp,v $
  292.  * Revision 1000.1  2004/06/01 19:40:16  gouriano
  293.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.6
  294.  *
  295.  * Revision 1.6  2004/05/17 21:06:02  gorelenk
  296.  * Added include of PCH ncbi_pch.hpp
  297.  *
  298.  * Revision 1.5  2003/10/01 21:15:15  ivanov
  299.  * Get rid of compilation warnings; some formal code rearrangement
  300.  *
  301.  * Revision 1.4  2003/07/30 12:42:22  ucko
  302.  * Properly initialize m_Finalized to false in the default constructor.
  303.  *
  304.  * Revision 1.3  2003/07/29 23:58:43  ucko
  305.  * Fix log for last revision, sigh.
  306.  *
  307.  * Revision 1.2  2003/07/29 23:57:33  ucko
  308.  * CMD5::GetHexSum: go up to 16 rather than sizeof(digest), as the latter
  309.  * is really just sizeof(unsigned char*) in this context.
  310.  *
  311.  * Revision 1.1  2003/07/29 21:29:26  ucko
  312.  * Add MD5 support (cribbed from the C Toolkit)
  313.  *
  314.  * ===========================================================================
  315.  */