| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 // | |
| 5 // The original source code is from: | |
| 6 // http://src.chromium.org/viewvc/chrome/trunk/src/base/md5.cc?revision=94203 | |
| 7 | |
| 8 // The original file was copied from sqlite, and was in the public domain. | |
| 9 | |
| 10 /* | |
| 11 * This code implements the MD5 message-digest algorithm. | |
| 12 * The algorithm is due to Ron Rivest. This code was | |
| 13 * written by Colin Plumb in 1993, no copyright is claimed. | |
| 14 * This code is in the public domain; do with it what you wish. | |
| 15 * | |
| 16 * Equivalent code is available from RSA Data Security, Inc. | |
| 17 * This code has been tested against that, and is equivalent, | |
| 18 * except that you don't need to include two pages of legalese | |
| 19 * with every copy. | |
| 20 * | |
| 21 * To compute the message digest of a chunk of bytes, declare an | |
| 22 * MD5Context structure, pass it to MD5Init, call MD5Update as | |
| 23 * needed on buffers full of bytes, and then call MD5Final, which | |
| 24 * will fill a supplied 16-byte array with the digest. | |
| 25 */ | |
| 26 | |
| 27 #include "md5.h" | |
| 28 | |
| 29 #include <libaddressinput/util/basictypes.h> | |
| 30 | |
| 31 #include <string> | |
| 32 | |
| 33 namespace { | |
| 34 | |
| 35 struct Context { | |
| 36 uint32 buf[4]; | |
| 37 uint32 bits[2]; | |
| 38 unsigned char in[64]; | |
| 39 }; | |
| 40 | |
| 41 /* | |
| 42 * Note: this code is harmless on little-endian machines. | |
| 43 */ | |
| 44 void byteReverse(unsigned char *buf, unsigned longs) { | |
| 45 uint32 t; | |
| 46 do { | |
| 47 t = (uint32)((unsigned)buf[3]<<8 | buf[2]) << 16 | | |
| 48 ((unsigned)buf[1]<<8 | buf[0]); | |
| 49 *(uint32 *)buf = t; | |
| 50 buf += 4; | |
| 51 } while (--longs); | |
| 52 } | |
| 53 | |
| 54 /* The four core functions - F1 is optimized somewhat */ | |
| 55 | |
| 56 /* #define F1(x, y, z) (x & y | ~x & z) */ | |
| 57 #define F1(x, y, z) (z ^ (x & (y ^ z))) | |
| 58 #define F2(x, y, z) F1(z, x, y) | |
| 59 #define F3(x, y, z) (x ^ y ^ z) | |
| 60 #define F4(x, y, z) (y ^ (x | ~z)) | |
| 61 | |
| 62 /* This is the central step in the MD5 algorithm. */ | |
| 63 #define MD5STEP(f, w, x, y, z, data, s) \ | |
| 64 ( w += f(x, y, z) + data, w = w<<s | w>>(32-s), w += x ) | |
| 65 | |
| 66 /* | |
| 67 * The core of the MD5 algorithm, this alters an existing MD5 hash to | |
| 68 * reflect the addition of 16 longwords of new data. MD5Update blocks | |
| 69 * the data and converts bytes into longwords for this routine. | |
| 70 */ | |
| 71 void MD5Transform(uint32 buf[4], const uint32 in[16]) { | |
| 72 register uint32 a, b, c, d; | |
| 73 | |
| 74 a = buf[0]; | |
| 75 b = buf[1]; | |
| 76 c = buf[2]; | |
| 77 d = buf[3]; | |
| 78 | |
| 79 MD5STEP(F1, a, b, c, d, in[ 0]+0xd76aa478, 7); | |
| 80 MD5STEP(F1, d, a, b, c, in[ 1]+0xe8c7b756, 12); | |
| 81 MD5STEP(F1, c, d, a, b, in[ 2]+0x242070db, 17); | |
| 82 MD5STEP(F1, b, c, d, a, in[ 3]+0xc1bdceee, 22); | |
| 83 MD5STEP(F1, a, b, c, d, in[ 4]+0xf57c0faf, 7); | |
| 84 MD5STEP(F1, d, a, b, c, in[ 5]+0x4787c62a, 12); | |
| 85 MD5STEP(F1, c, d, a, b, in[ 6]+0xa8304613, 17); | |
| 86 MD5STEP(F1, b, c, d, a, in[ 7]+0xfd469501, 22); | |
| 87 MD5STEP(F1, a, b, c, d, in[ 8]+0x698098d8, 7); | |
| 88 MD5STEP(F1, d, a, b, c, in[ 9]+0x8b44f7af, 12); | |
| 89 MD5STEP(F1, c, d, a, b, in[10]+0xffff5bb1, 17); | |
| 90 MD5STEP(F1, b, c, d, a, in[11]+0x895cd7be, 22); | |
| 91 MD5STEP(F1, a, b, c, d, in[12]+0x6b901122, 7); | |
| 92 MD5STEP(F1, d, a, b, c, in[13]+0xfd987193, 12); | |
| 93 MD5STEP(F1, c, d, a, b, in[14]+0xa679438e, 17); | |
| 94 MD5STEP(F1, b, c, d, a, in[15]+0x49b40821, 22); | |
| 95 | |
| 96 MD5STEP(F2, a, b, c, d, in[ 1]+0xf61e2562, 5); | |
| 97 MD5STEP(F2, d, a, b, c, in[ 6]+0xc040b340, 9); | |
| 98 MD5STEP(F2, c, d, a, b, in[11]+0x265e5a51, 14); | |
| 99 MD5STEP(F2, b, c, d, a, in[ 0]+0xe9b6c7aa, 20); | |
| 100 MD5STEP(F2, a, b, c, d, in[ 5]+0xd62f105d, 5); | |
| 101 MD5STEP(F2, d, a, b, c, in[10]+0x02441453, 9); | |
| 102 MD5STEP(F2, c, d, a, b, in[15]+0xd8a1e681, 14); | |
| 103 MD5STEP(F2, b, c, d, a, in[ 4]+0xe7d3fbc8, 20); | |
| 104 MD5STEP(F2, a, b, c, d, in[ 9]+0x21e1cde6, 5); | |
| 105 MD5STEP(F2, d, a, b, c, in[14]+0xc33707d6, 9); | |
| 106 MD5STEP(F2, c, d, a, b, in[ 3]+0xf4d50d87, 14); | |
| 107 MD5STEP(F2, b, c, d, a, in[ 8]+0x455a14ed, 20); | |
| 108 MD5STEP(F2, a, b, c, d, in[13]+0xa9e3e905, 5); | |
| 109 MD5STEP(F2, d, a, b, c, in[ 2]+0xfcefa3f8, 9); | |
| 110 MD5STEP(F2, c, d, a, b, in[ 7]+0x676f02d9, 14); | |
| 111 MD5STEP(F2, b, c, d, a, in[12]+0x8d2a4c8a, 20); | |
| 112 | |
| 113 MD5STEP(F3, a, b, c, d, in[ 5]+0xfffa3942, 4); | |
| 114 MD5STEP(F3, d, a, b, c, in[ 8]+0x8771f681, 11); | |
| 115 MD5STEP(F3, c, d, a, b, in[11]+0x6d9d6122, 16); | |
| 116 MD5STEP(F3, b, c, d, a, in[14]+0xfde5380c, 23); | |
| 117 MD5STEP(F3, a, b, c, d, in[ 1]+0xa4beea44, 4); | |
| 118 MD5STEP(F3, d, a, b, c, in[ 4]+0x4bdecfa9, 11); | |
| 119 MD5STEP(F3, c, d, a, b, in[ 7]+0xf6bb4b60, 16); | |
| 120 MD5STEP(F3, b, c, d, a, in[10]+0xbebfbc70, 23); | |
| 121 MD5STEP(F3, a, b, c, d, in[13]+0x289b7ec6, 4); | |
| 122 MD5STEP(F3, d, a, b, c, in[ 0]+0xeaa127fa, 11); | |
| 123 MD5STEP(F3, c, d, a, b, in[ 3]+0xd4ef3085, 16); | |
| 124 MD5STEP(F3, b, c, d, a, in[ 6]+0x04881d05, 23); | |
| 125 MD5STEP(F3, a, b, c, d, in[ 9]+0xd9d4d039, 4); | |
| 126 MD5STEP(F3, d, a, b, c, in[12]+0xe6db99e5, 11); | |
| 127 MD5STEP(F3, c, d, a, b, in[15]+0x1fa27cf8, 16); | |
| 128 MD5STEP(F3, b, c, d, a, in[ 2]+0xc4ac5665, 23); | |
| 129 | |
| 130 MD5STEP(F4, a, b, c, d, in[ 0]+0xf4292244, 6); | |
| 131 MD5STEP(F4, d, a, b, c, in[ 7]+0x432aff97, 10); | |
| 132 MD5STEP(F4, c, d, a, b, in[14]+0xab9423a7, 15); | |
| 133 MD5STEP(F4, b, c, d, a, in[ 5]+0xfc93a039, 21); | |
| 134 MD5STEP(F4, a, b, c, d, in[12]+0x655b59c3, 6); | |
| 135 MD5STEP(F4, d, a, b, c, in[ 3]+0x8f0ccc92, 10); | |
| 136 MD5STEP(F4, c, d, a, b, in[10]+0xffeff47d, 15); | |
| 137 MD5STEP(F4, b, c, d, a, in[ 1]+0x85845dd1, 21); | |
| 138 MD5STEP(F4, a, b, c, d, in[ 8]+0x6fa87e4f, 6); | |
| 139 MD5STEP(F4, d, a, b, c, in[15]+0xfe2ce6e0, 10); | |
| 140 MD5STEP(F4, c, d, a, b, in[ 6]+0xa3014314, 15); | |
| 141 MD5STEP(F4, b, c, d, a, in[13]+0x4e0811a1, 21); | |
| 142 MD5STEP(F4, a, b, c, d, in[ 4]+0xf7537e82, 6); | |
| 143 MD5STEP(F4, d, a, b, c, in[11]+0xbd3af235, 10); | |
| 144 MD5STEP(F4, c, d, a, b, in[ 2]+0x2ad7d2bb, 15); | |
| 145 MD5STEP(F4, b, c, d, a, in[ 9]+0xeb86d391, 21); | |
| 146 | |
| 147 buf[0] += a; | |
| 148 buf[1] += b; | |
| 149 buf[2] += c; | |
| 150 buf[3] += d; | |
| 151 } | |
| 152 | |
| 153 } // namespace | |
| 154 | |
| 155 namespace i18n { | |
| 156 namespace addressinput { | |
| 157 | |
| 158 /* | |
| 159 * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious | |
| 160 * initialization constants. | |
| 161 */ | |
| 162 void MD5Init(MD5Context* context) { | |
| 163 struct Context *ctx = (struct Context *)context; | |
| 164 ctx->buf[0] = 0x67452301; | |
| 165 ctx->buf[1] = 0xefcdab89; | |
| 166 ctx->buf[2] = 0x98badcfe; | |
| 167 ctx->buf[3] = 0x10325476; | |
| 168 ctx->bits[0] = 0; | |
| 169 ctx->bits[1] = 0; | |
| 170 } | |
| 171 | |
| 172 /* | |
| 173 * Update context to reflect the concatenation of another buffer full | |
| 174 * of bytes. | |
| 175 */ | |
| 176 void MD5Update(MD5Context* context, const std::string& data) { | |
| 177 const unsigned char* inbuf = (const unsigned char*)data.data(); | |
| 178 size_t len = data.size(); | |
| 179 struct Context *ctx = (struct Context *)context; | |
| 180 const unsigned char* buf = (const unsigned char*)inbuf; | |
| 181 uint32 t; | |
| 182 | |
| 183 /* Update bitcount */ | |
| 184 | |
| 185 t = ctx->bits[0]; | |
| 186 if ((ctx->bits[0] = t + ((uint32)len << 3)) < t) | |
| 187 ctx->bits[1]++; /* Carry from low to high */ | |
| 188 ctx->bits[1] += static_cast<uint32>(len >> 29); | |
| 189 | |
| 190 t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */ | |
| 191 | |
| 192 /* Handle any leading odd-sized chunks */ | |
| 193 | |
| 194 if (t) { | |
| 195 unsigned char *p = (unsigned char *)ctx->in + t; | |
| 196 | |
| 197 t = 64-t; | |
| 198 if (len < t) { | |
| 199 memcpy(p, buf, len); | |
| 200 return; | |
| 201 } | |
| 202 memcpy(p, buf, t); | |
| 203 byteReverse(ctx->in, 16); | |
| 204 MD5Transform(ctx->buf, (uint32 *)ctx->in); | |
| 205 buf += t; | |
| 206 len -= t; | |
| 207 } | |
| 208 | |
| 209 /* Process data in 64-byte chunks */ | |
| 210 | |
| 211 while (len >= 64) { | |
| 212 memcpy(ctx->in, buf, 64); | |
| 213 byteReverse(ctx->in, 16); | |
| 214 MD5Transform(ctx->buf, (uint32 *)ctx->in); | |
| 215 buf += 64; | |
| 216 len -= 64; | |
| 217 } | |
| 218 | |
| 219 /* Handle any remaining bytes of data. */ | |
| 220 | |
| 221 memcpy(ctx->in, buf, len); | |
| 222 } | |
| 223 | |
| 224 /* | |
| 225 * Final wrapup - pad to 64-byte boundary with the bit pattern | |
| 226 * 1 0* (64-bit count of bits processed, MSB-first) | |
| 227 */ | |
| 228 void MD5Final(MD5Digest* digest, MD5Context* context) { | |
| 229 struct Context *ctx = (struct Context *)context; | |
| 230 unsigned count; | |
| 231 unsigned char *p; | |
| 232 | |
| 233 /* Compute number of bytes mod 64 */ | |
| 234 count = (ctx->bits[0] >> 3) & 0x3F; | |
| 235 | |
| 236 /* Set the first char of padding to 0x80. This is safe since there is | |
| 237 always at least one byte free */ | |
| 238 p = ctx->in + count; | |
| 239 *p++ = 0x80; | |
| 240 | |
| 241 /* Bytes of padding needed to make 64 bytes */ | |
| 242 count = 64 - 1 - count; | |
| 243 | |
| 244 /* Pad out to 56 mod 64 */ | |
| 245 if (count < 8) { | |
| 246 /* Two lots of padding: Pad the first block to 64 bytes */ | |
| 247 memset(p, 0, count); | |
| 248 byteReverse(ctx->in, 16); | |
| 249 MD5Transform(ctx->buf, (uint32 *)ctx->in); | |
| 250 | |
| 251 /* Now fill the next block with 56 bytes */ | |
| 252 memset(ctx->in, 0, 56); | |
| 253 } else { | |
| 254 /* Pad block to 56 bytes */ | |
| 255 memset(p, 0, count-8); | |
| 256 } | |
| 257 byteReverse(ctx->in, 14); | |
| 258 | |
| 259 /* Append length in bits and transform */ | |
| 260 ((uint32 *)ctx->in)[ 14 ] = ctx->bits[0]; | |
| 261 ((uint32 *)ctx->in)[ 15 ] = ctx->bits[1]; | |
| 262 | |
| 263 MD5Transform(ctx->buf, (uint32 *)ctx->in); | |
| 264 byteReverse((unsigned char *)ctx->buf, 4); | |
| 265 memcpy(digest->a, ctx->buf, 16); | |
| 266 memset(ctx, 0, sizeof(*ctx)); /* In case it's sensitive */ | |
| 267 } | |
| 268 | |
| 269 std::string MD5DigestToBase16(const MD5Digest& digest) { | |
| 270 static char const zEncode[] = "0123456789abcdef"; | |
| 271 | |
| 272 std::string ret; | |
| 273 ret.resize(32); | |
| 274 | |
| 275 int j = 0; | |
| 276 for (int i = 0; i < 16; i ++) { | |
| 277 int a = digest.a[i]; | |
| 278 ret[j++] = zEncode[(a>>4)&0xf]; | |
| 279 ret[j++] = zEncode[a & 0xf]; | |
| 280 } | |
| 281 return ret; | |
| 282 } | |
| 283 | |
| 284 void MD5Sum(const void* data, size_t length, MD5Digest* digest) { | |
| 285 MD5Context ctx; | |
| 286 MD5Init(&ctx); | |
| 287 MD5Update(&ctx, | |
| 288 std::string(reinterpret_cast<const char*>(data), length)); | |
| 289 MD5Final(digest, &ctx); | |
| 290 } | |
| 291 | |
| 292 std::string MD5String(const std::string& str) { | |
| 293 MD5Digest digest; | |
| 294 MD5Sum(str.data(), str.length(), &digest); | |
| 295 return MD5DigestToBase16(digest); | |
| 296 } | |
| 297 | |
| 298 } // namespace addressinput | |
| 299 } // namespace i18n | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 389863002:
Remove Chrome's own version of libaddressinput in favor of the upstream. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src