← Back to branch summary

~pac72/ubuntu/lucid/ddd/devel

« back to all changes in this revision

Viewing changes to libiberty/md5.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Schepler
  • Date: 2005-07-10 02:24:07 UTC
  • mfrom: (1.2.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20050710022407-y2r2z9k2d8aelr94
Tags: 1:3.3.11-1
http://bugs.debian.org/300216
http://bugs.debian.org/294631
* New upstream release.
* Rebuild using g++-4.0.
* Drop obsolete Build-Depends on g++ and libstdc++5-3.3-dev.
  Closes: #300216.
* Remove Suggests on bashdb, which no longer exists.  Closes: #294631.
* New patch 003_data_path.diff: change default data directory to
  /usr/share/ddd, with /usr/share/ddd-$(VERSION) as an alternate,
  instead of the other way around.
* New patch 004_userinfo.diff: add --with-userinfo option to configure
  to make it easier to override the autodetection.
* Update to Standards-Version 3.6.2 (no changes needed).

Show diffs side-by-side

added added

removed removed

Lines of Context:
libiberty/md5.c
1
 
/* md5.c - Functions to compute MD5 message digest of files or memory blocks
2
 
   according to the definition of MD5 in RFC 1321 from April 1992.
3
 
   Copyright (C) 1995, 1996 Free Software Foundation, Inc.
4
 
 
5
 
   NOTE: This source is derived from an old version taken from the GNU C
6
 
   Library (glibc).
7
 
 
8
 
   This program is free software; you can redistribute it and/or modify it
9
 
   under the terms of the GNU General Public License as published by the
10
 
   Free Software Foundation; either version 2, or (at your option) any
11
 
   later version.
12
 
 
13
 
   This program is distributed in the hope that it will be useful,
14
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
 
   GNU General Public License for more details.
17
 
 
18
 
   You should have received a copy of the GNU General Public License
19
 
   along with this program; if not, write to the Free Software Foundation,
20
 
   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
21
 
 
22
 
/* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.  */
23
 
 
24
 
#ifdef HAVE_CONFIG_H
25
 
# include <config.h>
26
 
#endif
27
 
 
28
 
#include <sys/types.h>
29
 
 
30
 
#if STDC_HEADERS || defined _LIBC
31
 
# include <stdlib.h>
32
 
# include <string.h>
33
 
#else
34
 
# ifndef HAVE_MEMCPY
35
 
#  define memcpy(d, s, n) bcopy ((s), (d), (n))
36
 
# endif
37
 
#endif
38
 
 
39
 
#include "ansidecl.h"
40
 
#include "md5.h"
41
 
 
42
 
#ifdef _LIBC
43
 
# include <endian.h>
44
 
# if __BYTE_ORDER == __BIG_ENDIAN
45
 
#  define WORDS_BIGENDIAN 1
46
 
# endif
47
 
#endif
48
 
 
49
 
#ifdef WORDS_BIGENDIAN
50
 
# define SWAP(n)                                                        \
51
 
    (((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24))
52
 
#else
53
 
# define SWAP(n) (n)
54
 
#endif
55
 
 
56
 
 
57
 
/* This array contains the bytes used to pad the buffer to the next
58
 
   64-byte boundary.  (RFC 1321, 3.1: Step 1)  */
59
 
static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ...  */ };
60
 
 
61
 
 
62
 
/* Initialize structure containing state of computation.
63
 
   (RFC 1321, 3.3: Step 3)  */
64
 
void
65
 
md5_init_ctx (ctx)
66
 
     struct md5_ctx *ctx;
67
 
{
68
 
  ctx->A = (md5_uint32) 0x67452301;
69
 
  ctx->B = (md5_uint32) 0xefcdab89;
70
 
  ctx->C = (md5_uint32) 0x98badcfe;
71
 
  ctx->D = (md5_uint32) 0x10325476;
72
 
 
73
 
  ctx->total[0] = ctx->total[1] = 0;
74
 
  ctx->buflen = 0;
75
 
}
76
 
 
77
 
/* Put result from CTX in first 16 bytes following RESBUF.  The result
78
 
   must be in little endian byte order.
79
 
 
80
 
   IMPORTANT: On some systems it is required that RESBUF is correctly
81
 
   aligned for a 32 bits value.  */
82
 
void *
83
 
md5_read_ctx (ctx, resbuf)
84
 
     const struct md5_ctx *ctx;
85
 
     void *resbuf;
86
 
{
87
 
  ((md5_uint32 *) resbuf)[0] = SWAP (ctx->A);
88
 
  ((md5_uint32 *) resbuf)[1] = SWAP (ctx->B);
89
 
  ((md5_uint32 *) resbuf)[2] = SWAP (ctx->C);
90
 
  ((md5_uint32 *) resbuf)[3] = SWAP (ctx->D);
91
 
 
92
 
  return resbuf;
93
 
}
94
 
 
95
 
/* Process the remaining bytes in the internal buffer and the usual
96
 
   prolog according to the standard and write the result to RESBUF.
97
 
 
98
 
   IMPORTANT: On some systems it is required that RESBUF is correctly
99
 
   aligned for a 32 bits value.  */
100
 
void *
101
 
md5_finish_ctx (ctx, resbuf)
102
 
     struct md5_ctx *ctx;
103
 
     void *resbuf;
104
 
{
105
 
  /* Take yet unprocessed bytes into account.  */
106
 
  md5_uint32 bytes = ctx->buflen;
107
 
  size_t pad;
108
 
 
109
 
  /* Now count remaining bytes.  */
110
 
  ctx->total[0] += bytes;
111
 
  if (ctx->total[0] < bytes)
112
 
    ++ctx->total[1];
113
 
 
114
 
  pad = bytes >= 56 ? 64 + 56 - bytes : 56 - bytes;
115
 
  memcpy (&ctx->buffer[bytes], fillbuf, pad);
116
 
 
117
 
  /* Put the 64-bit file length in *bits* at the end of the buffer.  */
118
 
  *(md5_uint32 *) &ctx->buffer[bytes + pad] = SWAP (ctx->total[0] << 3);
119
 
  *(md5_uint32 *) &ctx->buffer[bytes + pad + 4] = SWAP ((ctx->total[1] << 3) |
120
 
                                                        (ctx->total[0] >> 29));
121
 
 
122
 
  /* Process last bytes.  */
123
 
  md5_process_block (ctx->buffer, bytes + pad + 8, ctx);
124
 
 
125
 
  return md5_read_ctx (ctx, resbuf);
126
 
}
127
 
 
128
 
/* Compute MD5 message digest for bytes read from STREAM.  The
129
 
   resulting message digest number will be written into the 16 bytes
130
 
   beginning at RESBLOCK.  */
131
 
int
132
 
md5_stream (stream, resblock)
133
 
     FILE *stream;
134
 
     void *resblock;
135
 
{
136
 
  /* Important: BLOCKSIZE must be a multiple of 64.  */
137
 
#define BLOCKSIZE 4096
138
 
  struct md5_ctx ctx;
139
 
  char buffer[BLOCKSIZE + 72];
140
 
  size_t sum;
141
 
 
142
 
  /* Initialize the computation context.  */
143
 
  md5_init_ctx (&ctx);
144
 
 
145
 
  /* Iterate over full file contents.  */
146
 
  while (1)
147
 
    {
148
 
      /* We read the file in blocks of BLOCKSIZE bytes.  One call of the
149
 
         computation function processes the whole buffer so that with the
150
 
         next round of the loop another block can be read.  */
151
 
      size_t n;
152
 
      sum = 0;
153
 
 
154
 
      /* Read block.  Take care for partial reads.  */
155
 
      do
156
 
        {
157
 
          n = fread (buffer + sum, 1, BLOCKSIZE - sum, stream);
158
 
 
159
 
          sum += n;
160
 
        }
161
 
      while (sum < BLOCKSIZE && n != 0);
162
 
      if (n == 0 && ferror (stream))
163
 
        return 1;
164
 
 
165
 
      /* If end of file is reached, end the loop.  */
166
 
      if (n == 0)
167
 
        break;
168
 
 
169
 
      /* Process buffer with BLOCKSIZE bytes.  Note that
170
 
                        BLOCKSIZE % 64 == 0
171
 
       */
172
 
      md5_process_block (buffer, BLOCKSIZE, &ctx);
173
 
    }
174
 
 
175
 
  /* Add the last bytes if necessary.  */
176
 
  if (sum > 0)
177
 
    md5_process_bytes (buffer, sum, &ctx);
178
 
 
179
 
  /* Construct result in desired memory.  */
180
 
  md5_finish_ctx (&ctx, resblock);
181
 
  return 0;
182
 
}
183
 
 
184
 
/* Compute MD5 message digest for LEN bytes beginning at BUFFER.  The
185
 
   result is always in little endian byte order, so that a byte-wise
186
 
   output yields to the wanted ASCII representation of the message
187
 
   digest.  */
188
 
void *
189
 
md5_buffer (buffer, len, resblock)
190
 
     const char *buffer;
191
 
     size_t len;
192
 
     void *resblock;
193
 
{
194
 
  struct md5_ctx ctx;
195
 
 
196
 
  /* Initialize the computation context.  */
197
 
  md5_init_ctx (&ctx);
198
 
 
199
 
  /* Process whole buffer but last len % 64 bytes.  */
200
 
  md5_process_bytes (buffer, len, &ctx);
201
 
 
202
 
  /* Put result in desired memory area.  */
203
 
  return md5_finish_ctx (&ctx, resblock);
204
 
}
205
 
 
206
 
 
207
 
void
208
 
md5_process_bytes (buffer, len, ctx)
209
 
     const void *buffer;
210
 
     size_t len;
211
 
     struct md5_ctx *ctx;
212
 
{
213
 
  /* When we already have some bits in our internal buffer concatenate
214
 
     both inputs first.  */
215
 
  if (ctx->buflen != 0)
216
 
    {
217
 
      size_t left_over = ctx->buflen;
218
 
      size_t add = 128 - left_over > len ? len : 128 - left_over;
219
 
 
220
 
      memcpy (&ctx->buffer[left_over], buffer, add);
221
 
      ctx->buflen += add;
222
 
 
223
 
      if (left_over + add > 64)
224
 
        {
225
 
          md5_process_block (ctx->buffer, (left_over + add) & ~63, ctx);
226
 
          /* The regions in the following copy operation cannot overlap.  */
227
 
          memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~63],
228
 
                  (left_over + add) & 63);
229
 
          ctx->buflen = (left_over + add) & 63;
230
 
        }
231
 
 
232
 
      buffer = (const void *) ((const char *) buffer + add);
233
 
      len -= add;
234
 
    }
235
 
 
236
 
  /* Process available complete blocks.  */
237
 
  if (len > 64)
238
 
    {
239
 
      md5_process_block (buffer, len & ~63, ctx);
240
 
      buffer = (const void *) ((const char *) buffer + (len & ~63));
241
 
      len &= 63;
242
 
    }
243
 
 
244
 
  /* Move remaining bytes in internal buffer.  */
245
 
  if (len > 0)
246
 
    {
247
 
      memcpy (ctx->buffer, buffer, len);
248
 
      ctx->buflen = len;
249
 
    }
250
 
}
251
 
 
252
 
 
253
 
/* These are the four functions used in the four steps of the MD5 algorithm
254
 
   and defined in the RFC 1321.  The first function is a little bit optimized
255
 
   (as found in Colin Plumbs public domain implementation).  */
256
 
/* #define FF(b, c, d) ((b & c) | (~b & d)) */
257
 
#define FF(b, c, d) (d ^ (b & (c ^ d)))
258
 
#define FG(b, c, d) FF (d, b, c)
259
 
#define FH(b, c, d) (b ^ c ^ d)
260
 
#define FI(b, c, d) (c ^ (b | ~d))
261
 
 
262
 
/* Process LEN bytes of BUFFER, accumulating context into CTX.
263
 
   It is assumed that LEN % 64 == 0.  */
264
 
 
265
 
void
266
 
md5_process_block (buffer, len, ctx)
267
 
     const void *buffer;
268
 
     size_t len;
269
 
     struct md5_ctx *ctx;
270
 
{
271
 
  md5_uint32 correct_words[16];
272
 
  const md5_uint32 *words = (const md5_uint32 *) buffer;
273
 
  size_t nwords = len / sizeof (md5_uint32);
274
 
  const md5_uint32 *endp = words + nwords;
275
 
  md5_uint32 A = ctx->A;
276
 
  md5_uint32 B = ctx->B;
277
 
  md5_uint32 C = ctx->C;
278
 
  md5_uint32 D = ctx->D;
279
 
 
280
 
  /* First increment the byte count.  RFC 1321 specifies the possible
281
 
     length of the file up to 2^64 bits.  Here we only compute the
282
 
     number of bytes.  Do a double word increment.  */
283
 
  ctx->total[0] += len;
284
 
  if (ctx->total[0] < len)
285
 
    ++ctx->total[1];
286
 
 
287
 
  /* Process all bytes in the buffer with 64 bytes in each round of
288
 
     the loop.  */
289
 
  while (words < endp)
290
 
    {
291
 
      md5_uint32 *cwp = correct_words;
292
 
      md5_uint32 A_save = A;
293
 
      md5_uint32 B_save = B;
294
 
      md5_uint32 C_save = C;
295
 
      md5_uint32 D_save = D;
296
 
 
297
 
      /* First round: using the given function, the context and a constant
298
 
         the next context is computed.  Because the algorithms processing
299
 
         unit is a 32-bit word and it is determined to work on words in
300
 
         little endian byte order we perhaps have to change the byte order
301
 
         before the computation.  To reduce the work for the next steps
302
 
         we store the swapped words in the array CORRECT_WORDS.  */
303
 
 
304
 
#define OP(a, b, c, d, s, T)                                            \
305
 
      do                                                                \
306
 
        {                                                               \
307
 
          a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T;             \
308
 
          ++words;                                                      \
309
 
          CYCLIC (a, s);                                                \
310
 
          a += b;                                                       \
311
 
        }                                                               \
312
 
      while (0)
313
 
 
314
 
      /* It is unfortunate that C does not provide an operator for
315
 
         cyclic rotation.  Hope the C compiler is smart enough.  */
316
 
#define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
317
 
 
318
 
      /* Before we start, one word to the strange constants.
319
 
         They are defined in RFC 1321 as
320
 
 
321
 
         T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
322
 
       */
323
 
 
324
 
      /* Round 1.  */
325
 
      OP (A, B, C, D,  7, (md5_uint32) 0xd76aa478);
326
 
      OP (D, A, B, C, 12, (md5_uint32) 0xe8c7b756);
327
 
      OP (C, D, A, B, 17, (md5_uint32) 0x242070db);
328
 
      OP (B, C, D, A, 22, (md5_uint32) 0xc1bdceee);
329
 
      OP (A, B, C, D,  7, (md5_uint32) 0xf57c0faf);
330
 
      OP (D, A, B, C, 12, (md5_uint32) 0x4787c62a);
331
 
      OP (C, D, A, B, 17, (md5_uint32) 0xa8304613);
332
 
      OP (B, C, D, A, 22, (md5_uint32) 0xfd469501);
333
 
      OP (A, B, C, D,  7, (md5_uint32) 0x698098d8);
334
 
      OP (D, A, B, C, 12, (md5_uint32) 0x8b44f7af);
335
 
      OP (C, D, A, B, 17, (md5_uint32) 0xffff5bb1);
336
 
      OP (B, C, D, A, 22, (md5_uint32) 0x895cd7be);
337
 
      OP (A, B, C, D,  7, (md5_uint32) 0x6b901122);
338
 
      OP (D, A, B, C, 12, (md5_uint32) 0xfd987193);
339
 
      OP (C, D, A, B, 17, (md5_uint32) 0xa679438e);
340
 
      OP (B, C, D, A, 22, (md5_uint32) 0x49b40821);
341
 
 
342
 
      /* For the second to fourth round we have the possibly swapped words
343
 
         in CORRECT_WORDS.  Redefine the macro to take an additional first
344
 
         argument specifying the function to use.  */
345
 
#undef OP
346
 
#define OP(a, b, c, d, k, s, T)                                         \
347
 
      do                                                                \
348
 
        {                                                               \
349
 
          a += FX (b, c, d) + correct_words[k] + T;                     \
350
 
          CYCLIC (a, s);                                                \
351
 
          a += b;                                                       \
352
 
        }                                                               \
353
 
      while (0)
354
 
 
355
 
#define FX(b, c, d) FG (b, c, d)
356
 
 
357
 
      /* Round 2.  */
358
 
      OP (A, B, C, D,  1,  5, (md5_uint32) 0xf61e2562);
359
 
      OP (D, A, B, C,  6,  9, (md5_uint32) 0xc040b340);
360
 
      OP (C, D, A, B, 11, 14, (md5_uint32) 0x265e5a51);
361
 
      OP (B, C, D, A,  0, 20, (md5_uint32) 0xe9b6c7aa);
362
 
      OP (A, B, C, D,  5,  5, (md5_uint32) 0xd62f105d);
363
 
      OP (D, A, B, C, 10,  9, (md5_uint32) 0x02441453);
364
 
      OP (C, D, A, B, 15, 14, (md5_uint32) 0xd8a1e681);
365
 
      OP (B, C, D, A,  4, 20, (md5_uint32) 0xe7d3fbc8);
366
 
      OP (A, B, C, D,  9,  5, (md5_uint32) 0x21e1cde6);
367
 
      OP (D, A, B, C, 14,  9, (md5_uint32) 0xc33707d6);
368
 
      OP (C, D, A, B,  3, 14, (md5_uint32) 0xf4d50d87);
369
 
      OP (B, C, D, A,  8, 20, (md5_uint32) 0x455a14ed);
370
 
      OP (A, B, C, D, 13,  5, (md5_uint32) 0xa9e3e905);
371
 
      OP (D, A, B, C,  2,  9, (md5_uint32) 0xfcefa3f8);
372
 
      OP (C, D, A, B,  7, 14, (md5_uint32) 0x676f02d9);
373
 
      OP (B, C, D, A, 12, 20, (md5_uint32) 0x8d2a4c8a);
374
 
 
375
 
#undef FX
376
 
#define FX(b, c, d) FH (b, c, d)
377
 
 
378
 
      /* Round 3.  */
379
 
      OP (A, B, C, D,  5,  4, (md5_uint32) 0xfffa3942);
380
 
      OP (D, A, B, C,  8, 11, (md5_uint32) 0x8771f681);
381
 
      OP (C, D, A, B, 11, 16, (md5_uint32) 0x6d9d6122);
382
 
      OP (B, C, D, A, 14, 23, (md5_uint32) 0xfde5380c);
383
 
      OP (A, B, C, D,  1,  4, (md5_uint32) 0xa4beea44);
384
 
      OP (D, A, B, C,  4, 11, (md5_uint32) 0x4bdecfa9);
385
 
      OP (C, D, A, B,  7, 16, (md5_uint32) 0xf6bb4b60);
386
 
      OP (B, C, D, A, 10, 23, (md5_uint32) 0xbebfbc70);
387
 
      OP (A, B, C, D, 13,  4, (md5_uint32) 0x289b7ec6);
388
 
      OP (D, A, B, C,  0, 11, (md5_uint32) 0xeaa127fa);
389
 
      OP (C, D, A, B,  3, 16, (md5_uint32) 0xd4ef3085);
390
 
      OP (B, C, D, A,  6, 23, (md5_uint32) 0x04881d05);
391
 
      OP (A, B, C, D,  9,  4, (md5_uint32) 0xd9d4d039);
392
 
      OP (D, A, B, C, 12, 11, (md5_uint32) 0xe6db99e5);
393
 
      OP (C, D, A, B, 15, 16, (md5_uint32) 0x1fa27cf8);
394
 
      OP (B, C, D, A,  2, 23, (md5_uint32) 0xc4ac5665);
395
 
 
396
 
#undef FX
397
 
#define FX(b, c, d) FI (b, c, d)
398
 
 
399
 
      /* Round 4.  */
400
 
      OP (A, B, C, D,  0,  6, (md5_uint32) 0xf4292244);
401
 
      OP (D, A, B, C,  7, 10, (md5_uint32) 0x432aff97);
402
 
      OP (C, D, A, B, 14, 15, (md5_uint32) 0xab9423a7);
403
 
      OP (B, C, D, A,  5, 21, (md5_uint32) 0xfc93a039);
404
 
      OP (A, B, C, D, 12,  6, (md5_uint32) 0x655b59c3);
405
 
      OP (D, A, B, C,  3, 10, (md5_uint32) 0x8f0ccc92);
406
 
      OP (C, D, A, B, 10, 15, (md5_uint32) 0xffeff47d);
407
 
      OP (B, C, D, A,  1, 21, (md5_uint32) 0x85845dd1);
408
 
      OP (A, B, C, D,  8,  6, (md5_uint32) 0x6fa87e4f);
409
 
      OP (D, A, B, C, 15, 10, (md5_uint32) 0xfe2ce6e0);
410
 
      OP (C, D, A, B,  6, 15, (md5_uint32) 0xa3014314);
411
 
      OP (B, C, D, A, 13, 21, (md5_uint32) 0x4e0811a1);
412
 
      OP (A, B, C, D,  4,  6, (md5_uint32) 0xf7537e82);
413
 
      OP (D, A, B, C, 11, 10, (md5_uint32) 0xbd3af235);
414
 
      OP (C, D, A, B,  2, 15, (md5_uint32) 0x2ad7d2bb);
415
 
      OP (B, C, D, A,  9, 21, (md5_uint32) 0xeb86d391);
416
 
 
417
 
      /* Add the starting values of the context.  */
418
 
      A += A_save;
419
 
      B += B_save;
420
 
      C += C_save;
421
 
      D += D_save;
422
 
    }
423
 
 
424
 
  /* Put checksum in context given as argument.  */
425
 
  ctx->A = A;
426
 
  ctx->B = B;
427
 
  ctx->C = C;
428
 
  ctx->D = D;
429
 
}