md5.h, md5.c: updated to latest version from gnulib. Buggy old md5.h causes problems with gcc 4.3 compiler. In md5.h __attribute__ is #define'd to no-op and causes mutt_md5 to enter inifinite loop while calling memcpy().

+90 -98

2 changed files

expand all

md5.c

md5.h

+85 -82

md5.c

··· 1 1 /* md5.c - Functions to compute MD5 message digest of files or memory blocks 2 2 according to the definition of MD5 in RFC 1321 from April 1992. 3 - Copyright (C) 1995, 1996, 2001, 2003, 2004, 2005 Free Software Foundation, Inc. 3 + Copyright (C) 1995,1996,1997,1999,2000,2001,2005,2006,2008 Free Software Foundation, Inc. 4 4 NOTE: The canonical source of this file is maintained with the GNU C 5 5 Library. Bugs can be reported to bug-glibc@prep.ai.mit.edu. 6 6 ··· 80 80 ctx->buflen = 0; 81 81 } 82 82 83 - /* Put result from CTX in first 16 bytes following RESBUF. The result 84 - must be in little endian byte order. 83 + /* Copy the 4 byte value from v into the memory location pointed to by *cp, 84 + If your architecture allows unaligned access this is equivalent to 85 + * (md5_uint32 *) cp = v */ 86 + static inline void 87 + set_uint32 (char *cp, md5_uint32 v) 88 + { 89 + memcpy (cp, &v, sizeof v); 90 + } 85 91 86 - IMPORTANT: On some systems it is required that RESBUF is correctly 87 - aligned for a 32 bits value. */ 92 + /* Put result from CTX in first 16 bytes following RESBUF. The result 93 + must be in little endian byte order. */ 88 94 void * 89 95 md5_read_ctx (const struct md5_ctx *ctx, void *resbuf) 90 96 { 91 - ((md5_uint32 *) resbuf)[0] = SWAP (ctx->A); 92 - ((md5_uint32 *) resbuf)[1] = SWAP (ctx->B); 93 - ((md5_uint32 *) resbuf)[2] = SWAP (ctx->C); 94 - ((md5_uint32 *) resbuf)[3] = SWAP (ctx->D); 97 + char *r = resbuf; 98 + set_uint32 (r + 0 * sizeof ctx->A, SWAP (ctx->A)); 99 + set_uint32 (r + 1 * sizeof ctx->B, SWAP (ctx->B)); 100 + set_uint32 (r + 2 * sizeof ctx->C, SWAP (ctx->C)); 101 + set_uint32 (r + 3 * sizeof ctx->D, SWAP (ctx->D)); 95 102 96 103 return resbuf; 97 104 } 98 105 99 106 /* Process the remaining bytes in the internal buffer and the usual 100 - prolog according to the standard and write the result to RESBUF. 101 - 102 - IMPORTANT: On some systems it is required that RESBUF is correctly 103 - aligned for a 32 bits value. */ 107 + prolog according to the standard and write the result to RESBUF. */ 104 108 void * 105 109 md5_finish_ctx (struct md5_ctx *ctx, void *resbuf) 106 110 { 107 111 /* Take yet unprocessed bytes into account. */ 108 112 md5_uint32 bytes = ctx->buflen; 109 - size_t pad; 113 + size_t size = (bytes < 56) ? 64 / 4 : 64 * 2 / 4; 110 114 111 115 /* Now count remaining bytes. */ 112 116 ctx->total[0] += bytes; 113 117 if (ctx->total[0] < bytes) 114 118 ++ctx->total[1]; 115 119 116 - pad = bytes >= 56 ? 64 + 56 - bytes : 56 - bytes; 117 - memcpy (&ctx->buffer[bytes], fillbuf, pad); 118 - 119 120 /* Put the 64-bit file length in *bits* at the end of the buffer. */ 120 - *(md5_uint32 *) &ctx->buffer[bytes + pad] = SWAP (ctx->total[0] << 3); 121 - *(md5_uint32 *) &ctx->buffer[bytes + pad + 4] = SWAP ((ctx->total[1] << 3) | 122 - (ctx->total[0] >> 29)); 121 + ctx->buffer[size - 2] = SWAP (ctx->total[0] << 3); 122 + ctx->buffer[size - 1] = SWAP ((ctx->total[1] << 3) | (ctx->total[0] >> 29)); 123 + 124 + memcpy (&((char *) ctx->buffer)[bytes], fillbuf, (size - 2) * 4 - bytes); 123 125 124 126 /* Process last bytes. */ 125 - md5_process_block (ctx->buffer, bytes + pad + 8, ctx); 127 + md5_process_block (ctx->buffer, size * 4, ctx); 126 128 127 129 return md5_read_ctx (ctx, resbuf); 128 130 } ··· 144 146 while (1) 145 147 { 146 148 /* We read the file in blocks of BLOCKSIZE bytes. One call of the 147 - computation function processes the whole buffer so that with the 148 - next round of the loop another block can be read. */ 149 + computation function processes the whole buffer so that with the 150 + next round of the loop another block can be read. */ 149 151 size_t n; 150 152 sum = 0; 151 153 ··· 162 164 if (n == 0) 163 165 { 164 166 /* Check for the error flag IFF N == 0, so that we don't 165 - exit the loop after a partial read due to e.g., EAGAIN 166 - or EWOULDBLOCK. */ 167 + exit the loop after a partial read due to e.g., EAGAIN 168 + or EWOULDBLOCK. */ 167 169 if (ferror (stream)) 168 170 return 1; 169 171 goto process_partial_block; ··· 177 179 } 178 180 179 181 /* Process buffer with BLOCKSIZE bytes. Note that 180 - BLOCKSIZE % 64 == 0 182 + BLOCKSIZE % 64 == 0 181 183 */ 182 184 md5_process_block (buffer, BLOCKSIZE, &ctx); 183 185 } 184 186 185 - process_partial_block:; 187 + process_partial_block: 186 188 187 189 /* Process any remaining bytes. */ 188 190 if (sum > 0) ··· 223 225 size_t left_over = ctx->buflen; 224 226 size_t add = 128 - left_over > len ? len : 128 - left_over; 225 227 226 - memcpy (&ctx->buffer[left_over], buffer, add); 228 + memcpy (&((char *) ctx->buffer)[left_over], buffer, add); 227 229 ctx->buflen += add; 228 230 229 231 if (ctx->buflen > 64) ··· 232 234 233 235 ctx->buflen &= 63; 234 236 /* The regions in the following copy operation cannot overlap. */ 235 - memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~63], 237 + memcpy (ctx->buffer, 238 + &((char *) ctx->buffer)[(left_over + add) & ~63], 236 239 ctx->buflen); 237 240 } 238 241 ··· 267 270 { 268 271 size_t left_over = ctx->buflen; 269 272 270 - memcpy (&ctx->buffer[left_over], buffer, len); 273 + memcpy (&((char *) ctx->buffer)[left_over], buffer, len); 271 274 left_over += len; 272 275 if (left_over >= 64) 273 276 { 274 277 md5_process_block (ctx->buffer, 64, ctx); 275 278 left_over -= 64; 276 - memcpy (ctx->buffer, &ctx->buffer[64], left_over); 279 + memcpy (ctx->buffer, &ctx->buffer[16], left_over); 277 280 } 278 281 ctx->buflen = left_over; 279 282 } ··· 322 325 md5_uint32 D_save = D; 323 326 324 327 /* First round: using the given function, the context and a constant 325 - the next context is computed. Because the algorithms processing 326 - unit is a 32-bit word and it is determined to work on words in 327 - little endian byte order we perhaps have to change the byte order 328 - before the computation. To reduce the work for the next steps 329 - we store the swapped words in the array CORRECT_WORDS. */ 328 + the next context is computed. Because the algorithms processing 329 + unit is a 32-bit word and it is determined to work on words in 330 + little endian byte order we perhaps have to change the byte order 331 + before the computation. To reduce the work for the next steps 332 + we store the swapped words in the array CORRECT_WORDS. */ 330 333 331 334 #define OP(a, b, c, d, s, T) \ 332 335 do \ ··· 339 342 while (0) 340 343 341 344 /* It is unfortunate that C does not provide an operator for 342 - cyclic rotation. Hope the C compiler is smart enough. */ 345 + cyclic rotation. Hope the C compiler is smart enough. */ 343 346 #define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s))) 344 347 345 348 /* Before we start, one word to the strange constants. 346 - They are defined in RFC 1321 as 349 + They are defined in RFC 1321 as 347 350 348 - T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64 351 + T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64 349 352 350 - Here is an equivalent invocation using Perl: 353 + Here is an equivalent invocation using Perl: 351 354 352 - perl -e 'foreach(1..64){printf "0x%08x\n", int (4294967296 * abs (sin $_))}' 355 + perl -e 'foreach(1..64){printf "0x%08x\n", int (4294967296 * abs (sin $_))}' 353 356 */ 354 357 355 358 /* Round 1. */ 356 - OP (A, B, C, D, 7, 0xd76aa478); 359 + OP (A, B, C, D, 7, 0xd76aa478); 357 360 OP (D, A, B, C, 12, 0xe8c7b756); 358 361 OP (C, D, A, B, 17, 0x242070db); 359 362 OP (B, C, D, A, 22, 0xc1bdceee); 360 - OP (A, B, C, D, 7, 0xf57c0faf); 363 + OP (A, B, C, D, 7, 0xf57c0faf); 361 364 OP (D, A, B, C, 12, 0x4787c62a); 362 365 OP (C, D, A, B, 17, 0xa8304613); 363 366 OP (B, C, D, A, 22, 0xfd469501); 364 - OP (A, B, C, D, 7, 0x698098d8); 367 + OP (A, B, C, D, 7, 0x698098d8); 365 368 OP (D, A, B, C, 12, 0x8b44f7af); 366 369 OP (C, D, A, B, 17, 0xffff5bb1); 367 370 OP (B, C, D, A, 22, 0x895cd7be); 368 - OP (A, B, C, D, 7, 0x6b901122); 371 + OP (A, B, C, D, 7, 0x6b901122); 369 372 OP (D, A, B, C, 12, 0xfd987193); 370 373 OP (C, D, A, B, 17, 0xa679438e); 371 374 OP (B, C, D, A, 22, 0x49b40821); 372 375 373 376 /* For the second to fourth round we have the possibly swapped words 374 - in CORRECT_WORDS. Redefine the macro to take an additional first 375 - argument specifying the function to use. */ 377 + in CORRECT_WORDS. Redefine the macro to take an additional first 378 + argument specifying the function to use. */ 376 379 #undef OP 377 380 #define OP(f, a, b, c, d, k, s, T) \ 378 381 do \ ··· 384 387 while (0) 385 388 386 389 /* Round 2. */ 387 - OP (FG, A, B, C, D, 1, 5, 0xf61e2562); 388 - OP (FG, D, A, B, C, 6, 9, 0xc040b340); 390 + OP (FG, A, B, C, D, 1, 5, 0xf61e2562); 391 + OP (FG, D, A, B, C, 6, 9, 0xc040b340); 389 392 OP (FG, C, D, A, B, 11, 14, 0x265e5a51); 390 - OP (FG, B, C, D, A, 0, 20, 0xe9b6c7aa); 391 - OP (FG, A, B, C, D, 5, 5, 0xd62f105d); 392 - OP (FG, D, A, B, C, 10, 9, 0x02441453); 393 + OP (FG, B, C, D, A, 0, 20, 0xe9b6c7aa); 394 + OP (FG, A, B, C, D, 5, 5, 0xd62f105d); 395 + OP (FG, D, A, B, C, 10, 9, 0x02441453); 393 396 OP (FG, C, D, A, B, 15, 14, 0xd8a1e681); 394 - OP (FG, B, C, D, A, 4, 20, 0xe7d3fbc8); 395 - OP (FG, A, B, C, D, 9, 5, 0x21e1cde6); 396 - OP (FG, D, A, B, C, 14, 9, 0xc33707d6); 397 - OP (FG, C, D, A, B, 3, 14, 0xf4d50d87); 398 - OP (FG, B, C, D, A, 8, 20, 0x455a14ed); 399 - OP (FG, A, B, C, D, 13, 5, 0xa9e3e905); 400 - OP (FG, D, A, B, C, 2, 9, 0xfcefa3f8); 401 - OP (FG, C, D, A, B, 7, 14, 0x676f02d9); 397 + OP (FG, B, C, D, A, 4, 20, 0xe7d3fbc8); 398 + OP (FG, A, B, C, D, 9, 5, 0x21e1cde6); 399 + OP (FG, D, A, B, C, 14, 9, 0xc33707d6); 400 + OP (FG, C, D, A, B, 3, 14, 0xf4d50d87); 401 + OP (FG, B, C, D, A, 8, 20, 0x455a14ed); 402 + OP (FG, A, B, C, D, 13, 5, 0xa9e3e905); 403 + OP (FG, D, A, B, C, 2, 9, 0xfcefa3f8); 404 + OP (FG, C, D, A, B, 7, 14, 0x676f02d9); 402 405 OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a); 403 406 404 407 /* Round 3. */ 405 - OP (FH, A, B, C, D, 5, 4, 0xfffa3942); 406 - OP (FH, D, A, B, C, 8, 11, 0x8771f681); 408 + OP (FH, A, B, C, D, 5, 4, 0xfffa3942); 409 + OP (FH, D, A, B, C, 8, 11, 0x8771f681); 407 410 OP (FH, C, D, A, B, 11, 16, 0x6d9d6122); 408 411 OP (FH, B, C, D, A, 14, 23, 0xfde5380c); 409 - OP (FH, A, B, C, D, 1, 4, 0xa4beea44); 410 - OP (FH, D, A, B, C, 4, 11, 0x4bdecfa9); 411 - OP (FH, C, D, A, B, 7, 16, 0xf6bb4b60); 412 + OP (FH, A, B, C, D, 1, 4, 0xa4beea44); 413 + OP (FH, D, A, B, C, 4, 11, 0x4bdecfa9); 414 + OP (FH, C, D, A, B, 7, 16, 0xf6bb4b60); 412 415 OP (FH, B, C, D, A, 10, 23, 0xbebfbc70); 413 - OP (FH, A, B, C, D, 13, 4, 0x289b7ec6); 414 - OP (FH, D, A, B, C, 0, 11, 0xeaa127fa); 415 - OP (FH, C, D, A, B, 3, 16, 0xd4ef3085); 416 - OP (FH, B, C, D, A, 6, 23, 0x04881d05); 417 - OP (FH, A, B, C, D, 9, 4, 0xd9d4d039); 416 + OP (FH, A, B, C, D, 13, 4, 0x289b7ec6); 417 + OP (FH, D, A, B, C, 0, 11, 0xeaa127fa); 418 + OP (FH, C, D, A, B, 3, 16, 0xd4ef3085); 419 + OP (FH, B, C, D, A, 6, 23, 0x04881d05); 420 + OP (FH, A, B, C, D, 9, 4, 0xd9d4d039); 418 421 OP (FH, D, A, B, C, 12, 11, 0xe6db99e5); 419 422 OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8); 420 - OP (FH, B, C, D, A, 2, 23, 0xc4ac5665); 423 + OP (FH, B, C, D, A, 2, 23, 0xc4ac5665); 421 424 422 425 /* Round 4. */ 423 - OP (FI, A, B, C, D, 0, 6, 0xf4292244); 424 - OP (FI, D, A, B, C, 7, 10, 0x432aff97); 426 + OP (FI, A, B, C, D, 0, 6, 0xf4292244); 427 + OP (FI, D, A, B, C, 7, 10, 0x432aff97); 425 428 OP (FI, C, D, A, B, 14, 15, 0xab9423a7); 426 - OP (FI, B, C, D, A, 5, 21, 0xfc93a039); 427 - OP (FI, A, B, C, D, 12, 6, 0x655b59c3); 428 - OP (FI, D, A, B, C, 3, 10, 0x8f0ccc92); 429 + OP (FI, B, C, D, A, 5, 21, 0xfc93a039); 430 + OP (FI, A, B, C, D, 12, 6, 0x655b59c3); 431 + OP (FI, D, A, B, C, 3, 10, 0x8f0ccc92); 429 432 OP (FI, C, D, A, B, 10, 15, 0xffeff47d); 430 - OP (FI, B, C, D, A, 1, 21, 0x85845dd1); 431 - OP (FI, A, B, C, D, 8, 6, 0x6fa87e4f); 433 + OP (FI, B, C, D, A, 1, 21, 0x85845dd1); 434 + OP (FI, A, B, C, D, 8, 6, 0x6fa87e4f); 432 435 OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0); 433 - OP (FI, C, D, A, B, 6, 15, 0xa3014314); 436 + OP (FI, C, D, A, B, 6, 15, 0xa3014314); 434 437 OP (FI, B, C, D, A, 13, 21, 0x4e0811a1); 435 - OP (FI, A, B, C, D, 4, 6, 0xf7537e82); 438 + OP (FI, A, B, C, D, 4, 6, 0xf7537e82); 436 439 OP (FI, D, A, B, C, 11, 10, 0xbd3af235); 437 - OP (FI, C, D, A, B, 2, 15, 0x2ad7d2bb); 438 - OP (FI, B, C, D, A, 9, 21, 0xeb86d391); 440 + OP (FI, C, D, A, B, 2, 15, 0x2ad7d2bb); 441 + OP (FI, B, C, D, A, 9, 21, 0xeb86d391); 439 442 440 443 /* Add the starting values of the context. */ 441 444 A += A_save;

+5 -16

md5.h

··· 1 1 /* Declaration of functions and data types used for MD5 sum computing 2 2 library functions. 3 - Copyright (C) 1995-1997,1999-2005 Free Software Foundation, Inc. 3 + Copyright (C) 1995-1997,1999,2000,2001,2004,2005,2006,2008 4 + Free Software Foundation, Inc. 4 5 5 6 NOTE: The canonical source of this file is maintained with the GNU C 6 7 Library. Bugs can be reported to bug-glibc@prep.ai.mit.edu. ··· 51 52 # endif 52 53 #endif 53 54 54 - #ifndef __attribute__ 55 - # if ! __GNUC_PREREQ (2,8) || __STRICT_ANSI__ 56 - # define __attribute__(x) 57 - # endif 58 - #endif 59 - 60 55 #ifndef _LIBC 61 56 # define __md5_buffer md5_buffer 62 57 # define __md5_finish_ctx md5_finish_ctx ··· 79 74 80 75 md5_uint32 total[2]; 81 76 md5_uint32 buflen; 82 - char buffer[128] __attribute__ ((__aligned__ (__alignof__ (md5_uint32)))); 77 + md5_uint32 buffer[32]; 83 78 }; 84 79 85 80 /* ··· 108 103 /* Process the remaining bytes in the buffer and put result from CTX 109 104 in first 16 bytes following RESBUF. The result is always in little 110 105 endian byte order, so that a byte-wise output yields to the wanted 111 - ASCII representation of the message digest. 112 - 113 - IMPORTANT: On some systems it is required that RESBUF be correctly 114 - aligned for a 32 bits value. */ 106 + ASCII representation of the message digest. */ 115 107 extern void *__md5_finish_ctx (struct md5_ctx *ctx, void *resbuf) __THROW; 116 108 117 109 118 110 /* Put result from CTX in first 16 bytes following RESBUF. The result is 119 111 always in little endian byte order, so that a byte-wise output yields 120 - to the wanted ASCII representation of the message digest. 121 - 122 - IMPORTANT: On some systems it is required that RESBUF is correctly 123 - aligned for a 32 bits value. */ 112 + to the wanted ASCII representation of the message digest. */ 124 113 extern void *__md5_read_ctx (const struct md5_ctx *ctx, void *resbuf) __THROW; 125 114 126 115

Configure Feed

Configure Feed