← Back to branch summary

~hamo/ubuntu/precise/grub2/grub2.hi_res

« back to all changes in this revision

Viewing changes to lib/libgcrypt/cipher/md5.c

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson, Colin Watson, Evan Broder, Mario Limonciello
  • Date: 2010-11-24 13:59:55 UTC
  • mfrom: (1.17.6 upstream) (17.6.15 experimental)
  • Revision ID: james.westby@ubuntu.com-20101124135955-r6ii5sepayr7jt53
Tags: 1.99~20101124-1ubuntu1
https://launchpad.net/bugs/677758
[ Colin Watson ]
* Resynchronise with Debian experimental.  Remaining changes:
  - Adjust for default Ubuntu boot options ("quiet splash").
  - Default to hiding the menu; holding down Shift at boot will show it.
  - Set a monochromatic theme for Ubuntu.
  - Apply Ubuntu GRUB Legacy changes to legacy update-grub script: title,
    recovery mode, quiet option, tweak how memtest86+ is displayed, and
    use UUIDs where appropriate.
  - Fix backslash-escaping in merge_debconf_into_conf.
  - Remove "GNU/Linux" from default distributor string.
  - Add crashkernel= options if kdump and makedumpfile are available.
  - If other operating systems are installed, then automatically unhide
    the menu.  Otherwise, if GRUB_HIDDEN_TIMEOUT is 0, then use keystatus
    if available to check whether Shift is pressed.  If it is, show the
    menu, otherwise boot immediately.  If keystatus is not available, then
    fall back to a short delay interruptible with Escape.
  - Allow Shift to interrupt 'sleep --interruptible'.
  - Don't display introductory message about line editing unless we're
    actually offering a shell prompt.  Don't clear the screen just before
    booting if we never drew the menu in the first place.
  - Remove some verbose messages printed before reading the configuration
    file.
  - Suppress progress messages as the kernel and initrd load for
    non-recovery kernel menu entries.
  - Change prepare_grub_to_access_device to handle filesystems
    loop-mounted on file images.
  - Ignore devices loop-mounted from files in 10_linux.
  - Show the boot menu if the previous boot failed, that is if it failed
    to get to the end of one of the normal runlevels.
  - Don't generate /boot/grub/device.map during grub-install or
    grub-mkconfig by default.
  - Adjust upgrade version checks for Ubuntu.
  - Don't display "GRUB loading" unless Shift is held down.
  - Adjust versions of grub-doc and grub-legacy-doc conflicts to tolerate
    our backport of the grub-doc split.
  - Fix LVM/RAID probing in the absence of /boot/grub/device.map.
  - Look for .mo files in /usr/share/locale-langpack as well, in
    preference.
  - Make sure GRUB_TIMEOUT isn't quoted unnecessarily.
  - Probe all devices in 'grub-probe --target=drive' if
    /boot/grub/device.map is missing.
  - Build-depend on qemu-kvm rather than qemu-system for grub-pc tests.
  - Use qemu rather than qemu-system-i386.
  - Program vesafb on BIOS systems rather than efifb.
  - Add a grub-rescue-efi-amd64 package containing a rescue CD-ROM image
    for EFI-AMD64.
  - On Wubi, don't ask for an install device, but just update wubildr
    using the diverted grub-install.
  - When embedding the core image in a post-MBR gap, check for and avoid
    sectors matching any of a list of known signatures.
  - Disable video_bochs and video_cirrus on PC BIOS systems, as probing
    PCI space seems to break on some systems.
* Downgrade "ACPI shutdown failed" error to a debug message, since it can
  cause spurious test failures.

[ Evan Broder ]
* Enable lua from grub-extras.
* Incorporate the bitop library into lua.
* Add enum_pci function to grub module in lua.
* Switch back to gfxpayload=keep by default, unless the video hardware
  is known to not support it.

[ Mario Limonciello ]
* Built part_msdos and vfat into bootx64.efi (LP: #677758)

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/libgcrypt/cipher/md5.c
1
 
/* md5.c - MD5 Message-Digest Algorithm
2
 
 * Copyright (C) 1995,1996,1998,1999,2001,2002,
3
 
 *               2003  Free Software Foundation, Inc.
4
 
 *
5
 
 * This file is part of Libgcrypt.
6
 
 *
7
 
 * Libgcrypt is free software; you can redistribute it and/or modify
8
 
 * it under the terms of the GNU Lesser General Public License as
9
 
 * published by the Free Software Foundation; either version 2.1 of
10
 
 * the License, or (at your option) any later version.
11
 
 *
12
 
 * Libgcrypt is distributed in the hope that it will be useful,
13
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
 
 * GNU Lesser General Public License for more details.
16
 
 *
17
 
 * You should have received a copy of the GNU Lesser General Public
18
 
 * License along with this program; if not, write to the Free Software
19
 
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20
 
 *
21
 
 * According to the definition of MD5 in RFC 1321 from April 1992.
22
 
 * NOTE: This is *not* the same file as the one from glibc.
23
 
 * Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995. 
24
 
 * heavily modified for GnuPG by Werner Koch <wk@gnupg.org> 
25
 
 */
26
 
 
27
 
/* Test values:
28
 
 * ""                  D4 1D 8C D9 8F 00 B2 04  E9 80 09 98 EC F8 42 7E
29
 
 * "a"                 0C C1 75 B9 C0 F1 B6 A8  31 C3 99 E2 69 77 26 61
30
 
 * "abc                90 01 50 98 3C D2 4F B0  D6 96 3F 7D 28 E1 7F 72
31
 
 * "message digest"    F9 6B 69 7D 7C B7 93 8D  52 5A 2F 31 AA F1 61 D0
32
 
 */
33
 
 
34
 
#include <config.h>
35
 
#include <stdio.h>
36
 
#include <stdlib.h>
37
 
#include <string.h>
38
 
 
39
 
#include "g10lib.h"
40
 
#include "memory.h"
41
 
#include "cipher.h"
42
 
 
43
 
#include "bithelp.h"
44
 
 
45
 
 
46
 
typedef struct {
47
 
    u32 A,B,C,D;          /* chaining variables */
48
 
    u32  nblocks;
49
 
    byte buf[64];
50
 
    int  count;
51
 
} MD5_CONTEXT;
52
 
 
53
 
 
54
 
static void
55
 
md5_init( void *context )
56
 
{
57
 
  MD5_CONTEXT *ctx = context;
58
 
 
59
 
  ctx->A = 0x67452301;
60
 
  ctx->B = 0xefcdab89;
61
 
  ctx->C = 0x98badcfe;
62
 
  ctx->D = 0x10325476;
63
 
 
64
 
  ctx->nblocks = 0;
65
 
  ctx->count = 0;
66
 
}
67
 
 
68
 
 
69
 
/* These are the four functions used in the four steps of the MD5 algorithm
70
 
   and defined in the RFC 1321.  The first function is a little bit optimized
71
 
   (as found in Colin Plumbs public domain implementation).  */
72
 
/* #define FF(b, c, d) ((b & c) | (~b & d)) */
73
 
#define FF(b, c, d) (d ^ (b & (c ^ d)))
74
 
#define FG(b, c, d) FF (d, b, c)
75
 
#define FH(b, c, d) (b ^ c ^ d)
76
 
#define FI(b, c, d) (c ^ (b | ~d))
77
 
 
78
 
 
79
 
/****************
80
 
 * transform n*64 bytes
81
 
 */
82
 
static void
83
 
transform ( MD5_CONTEXT *ctx, const unsigned char *data )
84
 
{
85
 
  u32 correct_words[16];
86
 
  register u32 A = ctx->A;
87
 
  register u32 B = ctx->B;
88
 
  register u32 C = ctx->C;
89
 
  register u32 D = ctx->D;
90
 
  u32 *cwp = correct_words;
91
 
    
92
 
#ifdef WORDS_BIGENDIAN
93
 
  { 
94
 
    int i;
95
 
    byte *p2, *p1;
96
 
    for(i=0, p1=data, p2=(byte*)correct_words; i < 16; i++, p2 += 4 )
97
 
      {
98
 
        p2[3] = *p1++;
99
 
        p2[2] = *p1++;
100
 
        p2[1] = *p1++;
101
 
        p2[0] = *p1++;
102
 
      }
103
 
  }
104
 
#else
105
 
  memcpy( correct_words, data, 64 );
106
 
#endif
107
 
 
108
 
 
109
 
#define OP(a, b, c, d, s, T) \
110
 
  do                                       \
111
 
    {                                      \
112
 
      a += FF (b, c, d) + (*cwp++) + T;    \
113
 
      a = rol(a, s);                       \
114
 
      a += b;                              \
115
 
    }                                      \
116
 
  while (0)
117
 
 
118
 
  /* Before we start, one word about the strange constants.
119
 
     They are defined in RFC 1321 as
120
 
 
121
 
     T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
122
 
  */
123
 
 
124
 
  /* Round 1.  */
125
 
  OP (A, B, C, D,  7, 0xd76aa478);
126
 
  OP (D, A, B, C, 12, 0xe8c7b756);
127
 
  OP (C, D, A, B, 17, 0x242070db);
128
 
  OP (B, C, D, A, 22, 0xc1bdceee);
129
 
  OP (A, B, C, D,  7, 0xf57c0faf);
130
 
  OP (D, A, B, C, 12, 0x4787c62a);
131
 
  OP (C, D, A, B, 17, 0xa8304613);
132
 
  OP (B, C, D, A, 22, 0xfd469501);
133
 
  OP (A, B, C, D,  7, 0x698098d8);
134
 
  OP (D, A, B, C, 12, 0x8b44f7af);
135
 
  OP (C, D, A, B, 17, 0xffff5bb1);
136
 
  OP (B, C, D, A, 22, 0x895cd7be);
137
 
  OP (A, B, C, D,  7, 0x6b901122);
138
 
  OP (D, A, B, C, 12, 0xfd987193);
139
 
  OP (C, D, A, B, 17, 0xa679438e);
140
 
  OP (B, C, D, A, 22, 0x49b40821);
141
 
 
142
 
#undef OP
143
 
#define OP(f, a, b, c, d, k, s, T)  \
144
 
    do                                                                \
145
 
      {                                                               \
146
 
        a += f (b, c, d) + correct_words[k] + T;                      \
147
 
        a = rol(a, s);                                                \
148
 
        a += b;                                                       \
149
 
      }                                                               \
150
 
    while (0)
151
 
 
152
 
  /* Round 2.  */
153
 
  OP (FG, A, B, C, D,  1,  5, 0xf61e2562);
154
 
  OP (FG, D, A, B, C,  6,  9, 0xc040b340);
155
 
  OP (FG, C, D, A, B, 11, 14, 0x265e5a51);
156
 
  OP (FG, B, C, D, A,  0, 20, 0xe9b6c7aa);
157
 
  OP (FG, A, B, C, D,  5,  5, 0xd62f105d);
158
 
  OP (FG, D, A, B, C, 10,  9, 0x02441453);
159
 
  OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);
160
 
  OP (FG, B, C, D, A,  4, 20, 0xe7d3fbc8);
161
 
  OP (FG, A, B, C, D,  9,  5, 0x21e1cde6);
162
 
  OP (FG, D, A, B, C, 14,  9, 0xc33707d6);
163
 
  OP (FG, C, D, A, B,  3, 14, 0xf4d50d87);
164
 
  OP (FG, B, C, D, A,  8, 20, 0x455a14ed);
165
 
  OP (FG, A, B, C, D, 13,  5, 0xa9e3e905);
166
 
  OP (FG, D, A, B, C,  2,  9, 0xfcefa3f8);
167
 
  OP (FG, C, D, A, B,  7, 14, 0x676f02d9);
168
 
  OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
169
 
 
170
 
  /* Round 3.  */
171
 
  OP (FH, A, B, C, D,  5,  4, 0xfffa3942);
172
 
  OP (FH, D, A, B, C,  8, 11, 0x8771f681);
173
 
  OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);
174
 
  OP (FH, B, C, D, A, 14, 23, 0xfde5380c);
175
 
  OP (FH, A, B, C, D,  1,  4, 0xa4beea44);
176
 
  OP (FH, D, A, B, C,  4, 11, 0x4bdecfa9);
177
 
  OP (FH, C, D, A, B,  7, 16, 0xf6bb4b60);
178
 
  OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);
179
 
  OP (FH, A, B, C, D, 13,  4, 0x289b7ec6);
180
 
  OP (FH, D, A, B, C,  0, 11, 0xeaa127fa);
181
 
  OP (FH, C, D, A, B,  3, 16, 0xd4ef3085);
182
 
  OP (FH, B, C, D, A,  6, 23, 0x04881d05);
183
 
  OP (FH, A, B, C, D,  9,  4, 0xd9d4d039);
184
 
  OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);
185
 
  OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);
186
 
  OP (FH, B, C, D, A,  2, 23, 0xc4ac5665);
187
 
 
188
 
  /* Round 4.  */
189
 
  OP (FI, A, B, C, D,  0,  6, 0xf4292244);
190
 
  OP (FI, D, A, B, C,  7, 10, 0x432aff97);
191
 
  OP (FI, C, D, A, B, 14, 15, 0xab9423a7);
192
 
  OP (FI, B, C, D, A,  5, 21, 0xfc93a039);
193
 
  OP (FI, A, B, C, D, 12,  6, 0x655b59c3);
194
 
  OP (FI, D, A, B, C,  3, 10, 0x8f0ccc92);
195
 
  OP (FI, C, D, A, B, 10, 15, 0xffeff47d);
196
 
  OP (FI, B, C, D, A,  1, 21, 0x85845dd1);
197
 
  OP (FI, A, B, C, D,  8,  6, 0x6fa87e4f);
198
 
  OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
199
 
  OP (FI, C, D, A, B,  6, 15, 0xa3014314);
200
 
  OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);
201
 
  OP (FI, A, B, C, D,  4,  6, 0xf7537e82);
202
 
  OP (FI, D, A, B, C, 11, 10, 0xbd3af235);
203
 
  OP (FI, C, D, A, B,  2, 15, 0x2ad7d2bb);
204
 
  OP (FI, B, C, D, A,  9, 21, 0xeb86d391);
205
 
 
206
 
  /* Put checksum in context given as argument.  */
207
 
  ctx->A += A;
208
 
  ctx->B += B;
209
 
  ctx->C += C;
210
 
  ctx->D += D;
211
 
}
212
 
 
213
 
 
214
 
 
215
 
/* The routine updates the message-digest context to
216
 
 * account for the presence of each of the characters inBuf[0..inLen-1]
217
 
 * in the message whose digest is being computed.
218
 
 */
219
 
static void
220
 
md5_write( void *context, const void *inbuf_arg , size_t inlen)
221
 
{
222
 
  const unsigned char *inbuf = inbuf_arg;
223
 
  MD5_CONTEXT *hd = context;
224
 
  
225
 
  if( hd->count == 64 )  /* flush the buffer */
226
 
    {
227
 
      transform( hd, hd->buf );
228
 
      _gcry_burn_stack (80+6*sizeof(void*));
229
 
      hd->count = 0;
230
 
      hd->nblocks++;
231
 
    }
232
 
  if( !inbuf )
233
 
    return;
234
 
 
235
 
  if( hd->count )
236
 
    {
237
 
      for( ; inlen && hd->count < 64; inlen-- )
238
 
        hd->buf[hd->count++] = *inbuf++;
239
 
      md5_write( hd, NULL, 0 );
240
 
      if( !inlen )
241
 
        return;
242
 
    }
243
 
  _gcry_burn_stack (80+6*sizeof(void*));
244
 
 
245
 
  while( inlen >= 64 ) 
246
 
    {
247
 
      transform( hd, inbuf );
248
 
      hd->count = 0;
249
 
      hd->nblocks++;
250
 
      inlen -= 64;
251
 
      inbuf += 64;
252
 
    }
253
 
  for( ; inlen && hd->count < 64; inlen-- )
254
 
    hd->buf[hd->count++] = *inbuf++;
255
 
 
256
 
}
257
 
 
258
 
 
259
 
 
260
 
/* The routine final terminates the message-digest computation and
261
 
 * ends with the desired message digest in mdContext->digest[0...15].
262
 
 * The handle is prepared for a new MD5 cycle.
263
 
 * Returns 16 bytes representing the digest.
264
 
 */
265
 
 
266
 
static void
267
 
md5_final( void *context)
268
 
{
269
 
  MD5_CONTEXT *hd = context;
270
 
  u32 t, msb, lsb;
271
 
  byte *p;
272
 
  
273
 
  md5_write(hd, NULL, 0); /* flush */;
274
 
 
275
 
  t = hd->nblocks;
276
 
  /* multiply by 64 to make a byte count */
277
 
  lsb = t << 6;
278
 
  msb = t >> 26;
279
 
  /* add the count */
280
 
  t = lsb;
281
 
  if( (lsb += hd->count) < t )
282
 
    msb++;
283
 
  /* multiply by 8 to make a bit count */
284
 
  t = lsb;
285
 
  lsb <<= 3;
286
 
  msb <<= 3;
287
 
  msb |= t >> 29;
288
 
 
289
 
  if( hd->count < 56 )  /* enough room */
290
 
    {
291
 
      hd->buf[hd->count++] = 0x80; /* pad */
292
 
      while( hd->count < 56 )
293
 
        hd->buf[hd->count++] = 0;  /* pad */
294
 
    }
295
 
  else  /* need one extra block */
296
 
    {
297
 
      hd->buf[hd->count++] = 0x80; /* pad character */
298
 
      while( hd->count < 64 )
299
 
        hd->buf[hd->count++] = 0;
300
 
      md5_write(hd, NULL, 0);  /* flush */;
301
 
      memset(hd->buf, 0, 56 ); /* fill next block with zeroes */
302
 
    }
303
 
  /* append the 64 bit count */
304
 
  hd->buf[56] = lsb        ;
305
 
  hd->buf[57] = lsb >>  8;
306
 
  hd->buf[58] = lsb >> 16;
307
 
  hd->buf[59] = lsb >> 24;
308
 
  hd->buf[60] = msb        ;
309
 
  hd->buf[61] = msb >>  8;
310
 
  hd->buf[62] = msb >> 16;
311
 
  hd->buf[63] = msb >> 24;
312
 
  transform( hd, hd->buf );
313
 
  _gcry_burn_stack (80+6*sizeof(void*));
314
 
 
315
 
  p = hd->buf;
316
 
#ifdef WORDS_BIGENDIAN
317
 
#define X(a) do { *p++ = hd->a      ; *p++ = hd->a >> 8;      \
318
 
                  *p++ = hd->a >> 16; *p++ = hd->a >> 24; } while(0)
319
 
#else /* little endian */
320
 
#define X(a) do { *(u32*)p = (*hd).a ; p += 4; } while(0)
321
 
#endif
322
 
  X(A);
323
 
  X(B);
324
 
  X(C);
325
 
  X(D);
326
 
#undef X
327
 
 
328
 
}
329
 
 
330
 
static byte *
331
 
md5_read( void *context )
332
 
{
333
 
  MD5_CONTEXT *hd = (MD5_CONTEXT *) context;
334
 
  return hd->buf;
335
 
}
336
 
 
337
 
static byte asn[18] = /* Object ID is 1.2.840.113549.2.5 */
338
 
  { 0x30, 0x20, 0x30, 0x0c, 0x06, 0x08, 0x2a, 0x86,0x48,
339
 
    0x86, 0xf7, 0x0d, 0x02, 0x05, 0x05, 0x00, 0x04, 0x10 };
340
 
 
341
 
static gcry_md_oid_spec_t oid_spec_md5[] =
342
 
  {
343
 
    /* iso.member-body.us.rsadsi.pkcs.pkcs-1.4 (md5WithRSAEncryption) */
344
 
    { "1.2.840.113549.1.1.4" },
345
 
    /* RSADSI digestAlgorithm MD5 */
346
 
    { "1.2.840.113549.2.5" },
347
 
    { NULL },
348
 
  };
349
 
 
350
 
gcry_md_spec_t _gcry_digest_spec_md5 =
351
 
  {
352
 
    "MD5", asn, DIM (asn), oid_spec_md5, 16,
353
 
    md5_init, md5_write, md5_final, md5_read,
354
 
    sizeof (MD5_CONTEXT)
355
 
  };