← Back to branch summary

~darkmuggle-deactivatedaccount/ubuntu/quantal/grub2/fix-872244

« back to all changes in this revision

Viewing changes to grub-core/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:
grub-core/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
  };