Wim van der Vegt / MD5

port of a small MD5 library (see http://www.zedwood.com/article/121/cpp-md5-function ). I have removed the stream functionality (saves about 10k flash and 8k RAM) Compatible with the latest mBed libs (only renamed a file).

Fork of MD5 by Hendrik Lipka

md5.cpp@1:02f58b9bbd44, 2016-11-14 (annotated)

Committer:
wvd_vegt
Date:
Mon Nov 14 11:27:24 2016 +0000
Revision:
1:02f58b9bbd44
Parent:
md5.c@0:8561cc01127c 
Changed the .c extension to .cpp to prevent cryptic compilation errors when using the latest mBed libs (129).

Who changed what in which revision?

UserRevisionLine numberNew contents of line
hlipka 0:8561cc01127c 1 /* MD5
hlipka 0:8561cc01127c 2 converted to C++ class by Frank Thilo (thilo@unix-ag.org)
hlipka 0:8561cc01127c 3 for bzflag (http://www.bzflag.org)
hlipka 0:8561cc01127c 4
hlipka 0:8561cc01127c 5 based on:
hlipka 0:8561cc01127c 6
hlipka 0:8561cc01127c 7 md5.h and md5.c
hlipka 0:8561cc01127c 8 reference implemantion of RFC 1321
hlipka 0:8561cc01127c 9
hlipka 0:8561cc01127c 10 Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
hlipka 0:8561cc01127c 11 rights reserved.
hlipka 0:8561cc01127c 12
hlipka 0:8561cc01127c 13 License to copy and use this software is granted provided that it
hlipka 0:8561cc01127c 14 is identified as the "RSA Data Security, Inc. MD5 Message-Digest
hlipka 0:8561cc01127c 15 Algorithm" in all material mentioning or referencing this software
hlipka 0:8561cc01127c 16 or this function.
hlipka 0:8561cc01127c 17
hlipka 0:8561cc01127c 18 License is also granted to make and use derivative works provided
hlipka 0:8561cc01127c 19 that such works are identified as "derived from the RSA Data
hlipka 0:8561cc01127c 20 Security, Inc. MD5 Message-Digest Algorithm" in all material
hlipka 0:8561cc01127c 21 mentioning or referencing the derived work.
hlipka 0:8561cc01127c 22
hlipka 0:8561cc01127c 23 RSA Data Security, Inc. makes no representations concerning either
hlipka 0:8561cc01127c 24 the merchantability of this software or the suitability of this
hlipka 0:8561cc01127c 25 software for any particular purpose. It is provided "as is"
hlipka 0:8561cc01127c 26 without express or implied warranty of any kind.
hlipka 0:8561cc01127c 27
hlipka 0:8561cc01127c 28 These notices must be retained in any copies of any part of this
hlipka 0:8561cc01127c 29 documentation and/or software.
hlipka 0:8561cc01127c 30
hlipka 0:8561cc01127c 31 */
hlipka 0:8561cc01127c 32
hlipka 0:8561cc01127c 33 /* interface header */
hlipka 0:8561cc01127c 34 #include "md5.h"
hlipka 0:8561cc01127c 35
hlipka 0:8561cc01127c 36 /* system implementation headers */
hlipka 0:8561cc01127c 37 #include <stdio.h>
hlipka 0:8561cc01127c 38 #include <string.h>
hlipka 0:8561cc01127c 39
hlipka 0:8561cc01127c 40
hlipka 0:8561cc01127c 41 // Constants for MD5Transform routine.
hlipka 0:8561cc01127c 42 #define S11 7
hlipka 0:8561cc01127c 43 #define S12 12
hlipka 0:8561cc01127c 44 #define S13 17
hlipka 0:8561cc01127c 45 #define S14 22
hlipka 0:8561cc01127c 46 #define S21 5
hlipka 0:8561cc01127c 47 #define S22 9
hlipka 0:8561cc01127c 48 #define S23 14
hlipka 0:8561cc01127c 49 #define S24 20
hlipka 0:8561cc01127c 50 #define S31 4
hlipka 0:8561cc01127c 51 #define S32 11
hlipka 0:8561cc01127c 52 #define S33 16
hlipka 0:8561cc01127c 53 #define S34 23
hlipka 0:8561cc01127c 54 #define S41 6
hlipka 0:8561cc01127c 55 #define S42 10
hlipka 0:8561cc01127c 56 #define S43 15
hlipka 0:8561cc01127c 57 #define S44 21
hlipka 0:8561cc01127c 58
hlipka 0:8561cc01127c 59 ///////////////////////////////////////////////
hlipka 0:8561cc01127c 60
hlipka 0:8561cc01127c 61 // F, G, H and I are basic MD5 functions.
hlipka 0:8561cc01127c 62 inline MD5::uint4 MD5::F(uint4 x, uint4 y, uint4 z) {
hlipka 0:8561cc01127c 63 return x&y | ~x&z;
hlipka 0:8561cc01127c 64 }
hlipka 0:8561cc01127c 65
hlipka 0:8561cc01127c 66 inline MD5::uint4 MD5::G(uint4 x, uint4 y, uint4 z) {
hlipka 0:8561cc01127c 67 return x&z | y&~z;
hlipka 0:8561cc01127c 68 }
hlipka 0:8561cc01127c 69
hlipka 0:8561cc01127c 70 inline MD5::uint4 MD5::H(uint4 x, uint4 y, uint4 z) {
hlipka 0:8561cc01127c 71 return x^y^z;
hlipka 0:8561cc01127c 72 }
hlipka 0:8561cc01127c 73
hlipka 0:8561cc01127c 74 inline MD5::uint4 MD5::I(uint4 x, uint4 y, uint4 z) {
hlipka 0:8561cc01127c 75 return y ^ (x | ~z);
hlipka 0:8561cc01127c 76 }
hlipka 0:8561cc01127c 77
hlipka 0:8561cc01127c 78 // rotate_left rotates x left n bits.
hlipka 0:8561cc01127c 79 inline MD5::uint4 MD5::rotate_left(uint4 x, int n) {
hlipka 0:8561cc01127c 80 return (x << n) | (x >> (32-n));
hlipka 0:8561cc01127c 81 }
hlipka 0:8561cc01127c 82
hlipka 0:8561cc01127c 83 // FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
hlipka 0:8561cc01127c 84 // Rotation is separate from addition to prevent recomputation.
hlipka 0:8561cc01127c 85 inline void MD5::FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
hlipka 0:8561cc01127c 86 a = rotate_left(a+ F(b,c,d) + x + ac, s) + b;
hlipka 0:8561cc01127c 87 }
hlipka 0:8561cc01127c 88
hlipka 0:8561cc01127c 89 inline void MD5::GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
hlipka 0:8561cc01127c 90 a = rotate_left(a + G(b,c,d) + x + ac, s) + b;
hlipka 0:8561cc01127c 91 }
hlipka 0:8561cc01127c 92
hlipka 0:8561cc01127c 93 inline void MD5::HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
hlipka 0:8561cc01127c 94 a = rotate_left(a + H(b,c,d) + x + ac, s) + b;
hlipka 0:8561cc01127c 95 }
hlipka 0:8561cc01127c 96
hlipka 0:8561cc01127c 97 inline void MD5::II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
hlipka 0:8561cc01127c 98 a = rotate_left(a + I(b,c,d) + x + ac, s) + b;
hlipka 0:8561cc01127c 99 }
hlipka 0:8561cc01127c 100
hlipka 0:8561cc01127c 101 //////////////////////////////////////////////
hlipka 0:8561cc01127c 102
hlipka 0:8561cc01127c 103 // default ctor, just initailize
hlipka 0:8561cc01127c 104 MD5::MD5()
hlipka 0:8561cc01127c 105 {
hlipka 0:8561cc01127c 106 init();
hlipka 0:8561cc01127c 107 }
hlipka 0:8561cc01127c 108
hlipka 0:8561cc01127c 109 //////////////////////////////////////////////
hlipka 0:8561cc01127c 110
hlipka 0:8561cc01127c 111 // nifty shortcut ctor, compute MD5 for string and finalize it right away
hlipka 0:8561cc01127c 112 MD5::MD5(const std::string &text)
hlipka 0:8561cc01127c 113 {
hlipka 0:8561cc01127c 114 init();
hlipka 0:8561cc01127c 115 update(text.c_str(), text.length());
hlipka 0:8561cc01127c 116 finalize();
hlipka 0:8561cc01127c 117 }
hlipka 0:8561cc01127c 118
hlipka 0:8561cc01127c 119 //////////////////////////////
hlipka 0:8561cc01127c 120
hlipka 0:8561cc01127c 121 void MD5::init()
hlipka 0:8561cc01127c 122 {
hlipka 0:8561cc01127c 123 finalized=false;
hlipka 0:8561cc01127c 124
hlipka 0:8561cc01127c 125 count[0] = 0;
hlipka 0:8561cc01127c 126 count[1] = 0;
hlipka 0:8561cc01127c 127
hlipka 0:8561cc01127c 128 // load magic initialization constants.
hlipka 0:8561cc01127c 129 state[0] = 0x67452301;
hlipka 0:8561cc01127c 130 state[1] = 0xefcdab89;
hlipka 0:8561cc01127c 131 state[2] = 0x98badcfe;
hlipka 0:8561cc01127c 132 state[3] = 0x10325476;
hlipka 0:8561cc01127c 133 }
hlipka 0:8561cc01127c 134
hlipka 0:8561cc01127c 135 //////////////////////////////
hlipka 0:8561cc01127c 136
hlipka 0:8561cc01127c 137 // decodes input (unsigned char) into output (uint4). Assumes len is a multiple of 4.
hlipka 0:8561cc01127c 138 void MD5::decode(uint4 output[], const uint1 input[], size_type len)
hlipka 0:8561cc01127c 139 {
hlipka 0:8561cc01127c 140 for (unsigned int i = 0, j = 0; j < len; i++, j += 4)
hlipka 0:8561cc01127c 141 output[i] = ((uint4)input[j]) | (((uint4)input[j+1]) << 8) |
hlipka 0:8561cc01127c 142 (((uint4)input[j+2]) << 16) | (((uint4)input[j+3]) << 24);
hlipka 0:8561cc01127c 143 }
hlipka 0:8561cc01127c 144
hlipka 0:8561cc01127c 145 //////////////////////////////
hlipka 0:8561cc01127c 146
hlipka 0:8561cc01127c 147 // encodes input (uint4) into output (unsigned char). Assumes len is
hlipka 0:8561cc01127c 148 // a multiple of 4.
hlipka 0:8561cc01127c 149 void MD5::encode(uint1 output[], const uint4 input[], size_type len)
hlipka 0:8561cc01127c 150 {
hlipka 0:8561cc01127c 151 for (size_type i = 0, j = 0; j < len; i++, j += 4) {
hlipka 0:8561cc01127c 152 output[j] = input[i] & 0xff;
hlipka 0:8561cc01127c 153 output[j+1] = (input[i] >> 8) & 0xff;
hlipka 0:8561cc01127c 154 output[j+2] = (input[i] >> 16) & 0xff;
hlipka 0:8561cc01127c 155 output[j+3] = (input[i] >> 24) & 0xff;
hlipka 0:8561cc01127c 156 }
hlipka 0:8561cc01127c 157 }
hlipka 0:8561cc01127c 158
hlipka 0:8561cc01127c 159 //////////////////////////////
hlipka 0:8561cc01127c 160
hlipka 0:8561cc01127c 161 // apply MD5 algo on a block
hlipka 0:8561cc01127c 162 void MD5::transform(const uint1 block[blocksize])
hlipka 0:8561cc01127c 163 {
hlipka 0:8561cc01127c 164 uint4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
hlipka 0:8561cc01127c 165 decode (x, block, blocksize);
hlipka 0:8561cc01127c 166
hlipka 0:8561cc01127c 167 /* Round 1 */
hlipka 0:8561cc01127c 168 FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
hlipka 0:8561cc01127c 169 FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
hlipka 0:8561cc01127c 170 FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
hlipka 0:8561cc01127c 171 FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
hlipka 0:8561cc01127c 172 FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
hlipka 0:8561cc01127c 173 FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
hlipka 0:8561cc01127c 174 FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
hlipka 0:8561cc01127c 175 FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
hlipka 0:8561cc01127c 176 FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
hlipka 0:8561cc01127c 177 FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
hlipka 0:8561cc01127c 178 FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
hlipka 0:8561cc01127c 179 FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
hlipka 0:8561cc01127c 180 FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
hlipka 0:8561cc01127c 181 FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
hlipka 0:8561cc01127c 182 FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
hlipka 0:8561cc01127c 183 FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
hlipka 0:8561cc01127c 184
hlipka 0:8561cc01127c 185 /* Round 2 */
hlipka 0:8561cc01127c 186 GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
hlipka 0:8561cc01127c 187 GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
hlipka 0:8561cc01127c 188 GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
hlipka 0:8561cc01127c 189 GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
hlipka 0:8561cc01127c 190 GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
hlipka 0:8561cc01127c 191 GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
hlipka 0:8561cc01127c 192 GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
hlipka 0:8561cc01127c 193 GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
hlipka 0:8561cc01127c 194 GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
hlipka 0:8561cc01127c 195 GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
hlipka 0:8561cc01127c 196 GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
hlipka 0:8561cc01127c 197 GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
hlipka 0:8561cc01127c 198 GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
hlipka 0:8561cc01127c 199 GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
hlipka 0:8561cc01127c 200 GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
hlipka 0:8561cc01127c 201 GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
hlipka 0:8561cc01127c 202
hlipka 0:8561cc01127c 203 /* Round 3 */
hlipka 0:8561cc01127c 204 HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
hlipka 0:8561cc01127c 205 HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
hlipka 0:8561cc01127c 206 HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
hlipka 0:8561cc01127c 207 HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
hlipka 0:8561cc01127c 208 HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
hlipka 0:8561cc01127c 209 HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
hlipka 0:8561cc01127c 210 HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
hlipka 0:8561cc01127c 211 HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
hlipka 0:8561cc01127c 212 HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
hlipka 0:8561cc01127c 213 HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
hlipka 0:8561cc01127c 214 HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
hlipka 0:8561cc01127c 215 HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
hlipka 0:8561cc01127c 216 HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
hlipka 0:8561cc01127c 217 HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
hlipka 0:8561cc01127c 218 HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
hlipka 0:8561cc01127c 219 HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
hlipka 0:8561cc01127c 220
hlipka 0:8561cc01127c 221 /* Round 4 */
hlipka 0:8561cc01127c 222 II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
hlipka 0:8561cc01127c 223 II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
hlipka 0:8561cc01127c 224 II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
hlipka 0:8561cc01127c 225 II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
hlipka 0:8561cc01127c 226 II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
hlipka 0:8561cc01127c 227 II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
hlipka 0:8561cc01127c 228 II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
hlipka 0:8561cc01127c 229 II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
hlipka 0:8561cc01127c 230 II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
hlipka 0:8561cc01127c 231 II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
hlipka 0:8561cc01127c 232 II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
hlipka 0:8561cc01127c 233 II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
hlipka 0:8561cc01127c 234 II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
hlipka 0:8561cc01127c 235 II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
hlipka 0:8561cc01127c 236 II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
hlipka 0:8561cc01127c 237 II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
hlipka 0:8561cc01127c 238
hlipka 0:8561cc01127c 239 state[0] += a;
hlipka 0:8561cc01127c 240 state[1] += b;
hlipka 0:8561cc01127c 241 state[2] += c;
hlipka 0:8561cc01127c 242 state[3] += d;
hlipka 0:8561cc01127c 243
hlipka 0:8561cc01127c 244 // Zeroize sensitive information.
hlipka 0:8561cc01127c 245 memset(x, 0, sizeof x);
hlipka 0:8561cc01127c 246 }
hlipka 0:8561cc01127c 247
hlipka 0:8561cc01127c 248 //////////////////////////////
hlipka 0:8561cc01127c 249
hlipka 0:8561cc01127c 250 // MD5 block update operation. Continues an MD5 message-digest
hlipka 0:8561cc01127c 251 // operation, processing another message block
hlipka 0:8561cc01127c 252 void MD5::update(const unsigned char input[], size_type length)
hlipka 0:8561cc01127c 253 {
hlipka 0:8561cc01127c 254 // compute number of bytes mod 64
hlipka 0:8561cc01127c 255 size_type index = count[0] / 8 % blocksize;
hlipka 0:8561cc01127c 256
hlipka 0:8561cc01127c 257 // Update number of bits
hlipka 0:8561cc01127c 258 if ((count[0] += (length << 3)) < (length << 3))
hlipka 0:8561cc01127c 259 count[1]++;
hlipka 0:8561cc01127c 260 count[1] += (length >> 29);
hlipka 0:8561cc01127c 261
hlipka 0:8561cc01127c 262 // number of bytes we need to fill in buffer
hlipka 0:8561cc01127c 263 size_type firstpart = 64 - index;
hlipka 0:8561cc01127c 264
hlipka 0:8561cc01127c 265 size_type i;
hlipka 0:8561cc01127c 266
hlipka 0:8561cc01127c 267 // transform as many times as possible.
hlipka 0:8561cc01127c 268 if (length >= firstpart)
hlipka 0:8561cc01127c 269 {
hlipka 0:8561cc01127c 270 // fill buffer first, transform
hlipka 0:8561cc01127c 271 memcpy(&buffer[index], input, firstpart);
hlipka 0:8561cc01127c 272 transform(buffer);
hlipka 0:8561cc01127c 273
hlipka 0:8561cc01127c 274 // transform chunks of blocksize (64 bytes)
hlipka 0:8561cc01127c 275 for (i = firstpart; i + blocksize <= length; i += blocksize)
hlipka 0:8561cc01127c 276 transform(&input[i]);
hlipka 0:8561cc01127c 277
hlipka 0:8561cc01127c 278 index = 0;
hlipka 0:8561cc01127c 279 }
hlipka 0:8561cc01127c 280 else
hlipka 0:8561cc01127c 281 i = 0;
hlipka 0:8561cc01127c 282
hlipka 0:8561cc01127c 283 // buffer remaining input
hlipka 0:8561cc01127c 284 memcpy(&buffer[index], &input[i], length-i);
hlipka 0:8561cc01127c 285 }
hlipka 0:8561cc01127c 286
hlipka 0:8561cc01127c 287 //////////////////////////////
hlipka 0:8561cc01127c 288
hlipka 0:8561cc01127c 289 // for convenience provide a verson with signed char
hlipka 0:8561cc01127c 290 void MD5::update(const char input[], size_type length)
hlipka 0:8561cc01127c 291 {
hlipka 0:8561cc01127c 292 update((const unsigned char*)input, length);
hlipka 0:8561cc01127c 293 }
hlipka 0:8561cc01127c 294
hlipka 0:8561cc01127c 295 //////////////////////////////
hlipka 0:8561cc01127c 296
hlipka 0:8561cc01127c 297 // MD5 finalization. Ends an MD5 message-digest operation, writing the
hlipka 0:8561cc01127c 298 // the message digest and zeroizing the context.
hlipka 0:8561cc01127c 299 MD5& MD5::finalize()
hlipka 0:8561cc01127c 300 {
hlipka 0:8561cc01127c 301 static unsigned char padding[64] = {
hlipka 0:8561cc01127c 302 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
hlipka 0:8561cc01127c 303 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
hlipka 0:8561cc01127c 304 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
hlipka 0:8561cc01127c 305 };
hlipka 0:8561cc01127c 306
hlipka 0:8561cc01127c 307 if (!finalized) {
hlipka 0:8561cc01127c 308 // Save number of bits
hlipka 0:8561cc01127c 309 unsigned char bits[8];
hlipka 0:8561cc01127c 310 encode(bits, count, 8);
hlipka 0:8561cc01127c 311
hlipka 0:8561cc01127c 312 // pad out to 56 mod 64.
hlipka 0:8561cc01127c 313 size_type index = count[0] / 8 % 64;
hlipka 0:8561cc01127c 314 size_type padLen = (index < 56) ? (56 - index) : (120 - index);
hlipka 0:8561cc01127c 315 update(padding, padLen);
hlipka 0:8561cc01127c 316
hlipka 0:8561cc01127c 317 // Append length (before padding)
hlipka 0:8561cc01127c 318 update(bits, 8);
hlipka 0:8561cc01127c 319
hlipka 0:8561cc01127c 320 // Store state in digest
hlipka 0:8561cc01127c 321 encode(digest, state, 16);
hlipka 0:8561cc01127c 322
hlipka 0:8561cc01127c 323 // Zeroize sensitive information.
hlipka 0:8561cc01127c 324 memset(buffer, 0, sizeof buffer);
hlipka 0:8561cc01127c 325 memset(count, 0, sizeof count);
hlipka 0:8561cc01127c 326
hlipka 0:8561cc01127c 327 finalized=true;
hlipka 0:8561cc01127c 328 }
hlipka 0:8561cc01127c 329
hlipka 0:8561cc01127c 330 return *this;
hlipka 0:8561cc01127c 331 }
hlipka 0:8561cc01127c 332
hlipka 0:8561cc01127c 333 //////////////////////////////
hlipka 0:8561cc01127c 334
hlipka 0:8561cc01127c 335 // return hex representation of digest as string
hlipka 0:8561cc01127c 336 std::string MD5::hexdigest() const
hlipka 0:8561cc01127c 337 {
hlipka 0:8561cc01127c 338 if (!finalized)
hlipka 0:8561cc01127c 339 return "";
hlipka 0:8561cc01127c 340
hlipka 0:8561cc01127c 341 char buf[33];
hlipka 0:8561cc01127c 342 for (int i=0; i<16; i++)
hlipka 0:8561cc01127c 343 sprintf(buf+i*2, "%02x", digest[i]);
hlipka 0:8561cc01127c 344 buf[32]=0;
hlipka 0:8561cc01127c 345
hlipka 0:8561cc01127c 346 return std::string(buf);
hlipka 0:8561cc01127c 347 }
hlipka 0:8561cc01127c 348
hlipka 0:8561cc01127c 349 //////////////////////////////
hlipka 0:8561cc01127c 350
hlipka 0:8561cc01127c 351 std::string md5(const std::string str)
hlipka 0:8561cc01127c 352 {
hlipka 0:8561cc01127c 353 MD5 md5 = MD5(str);
hlipka 0:8561cc01127c 354
hlipka 0:8561cc01127c 355 return md5.hexdigest();
hlipka 0:8561cc01127c 356 }